I agree, though, that compared to Haskell and Rust it doesn't give you much. Dialyzer is (intentionally) a fail-open checker that doesn't allow expressing generics; I've had a rough time getting it to tell me my code is wrong. Credo is (intentionally) just a style linter. "Just let it crash" isn't useful when you're talking about code that is going to break because of its structural incoherence (a class of errors type-checker are good at catching), and not because of transient errors in external dependencies.

> I mean this sincerely — are you _sure_ you didn't get me confused with someone else? I was definitely a dick from what I can see from the Twitter history and I apologize. However, I cannot remember and cannot find myself ever saying or implying something as horrendous as what you're describing here.

https://twitter.com/bitemyapp/status/477359528510382080

  [@bitemyapp] @KirinDave my first workflow video is up to 
  1,535 views on Youtube so far. Who knows how many people 
  have used my guide. I'm feeling good.

  [@KirinDave] @bitemyapp It is not about your traffic, it is 
  about their excitement. Get over yourself.

  [@bitemyapp] @KirinDave Drinking the haterade tonight. Some 
  of those pregger hormones transfer over?
  
  Should ramp up theft of Clojure library authors >:)

  [@KirinDave] @bitemyapp Yeah I'm hysterical that's real cool.

  function somefunction(somestring/*: string*/)/*: boolean */ {
     var ret/*: boolean */;
     ...
     return ret;
  }

I'm kind of curious what you've run into personally. Having a dependency without any type-defs get silently treated as `any` is my own beef, but I haven't hit much else yet.

(Some type-defs' use for `any` also gets my goat, such as Promise's catch argument and some of the lodash functions, but I'm considering that a separate thing.)

​

> And honestly, some of the decisions around the language just feel strange. Not knowing what kind of bool to use [0] is pretty emblematic of where it is going as a language.

This is more an existing JS weirdness (`true`/`false` vs `Boolean()`); Flow doesn't mess with runtime semantics, only adding a layer that you check with then strip out.

And TypeScript has the same thing:

  var a: boolean = new Boolean(1);
  
  // Produces:
  // NewTypering.ts(29,5): error TS2322: Type 'Boolean' is not assignable to type 'boolean'.

Haskell does this by representing IO actions as values, eg. "IO String" (something like "IO", for people more familiar with that syntax), representing an IO action that, when later evaluated, will yield a string that you can use in subsequent actions.

Haskell's "main" (entry-point) function is a value of type "IO ()" (IO of a value representing nothing useful; you don't get anything out of it, so you just have a nothing placeholder). When a Haskell program is run, it ostensibly (hand-waving here) takes that IO value and interprets it, performing the action IO.

You have functions like putStrLn (print a line) that takes a String, and returns an "IO ()" . Accordingly, if you have

  main = putStrLn "Hello, World!"

  main =
    readLn >>= (\x -> putStrLn ("Hello, " ++ x))

The key bit is that it's just "IO Blah" values standing in for IO actions, and like jigsaw pieces, these IO-returning functions only fit together where the types line up, restricting how you can use them.

Monads are tangential to this; the type-checking of that jigsaw puzzle is what matters here.

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

Points: 106

# Comments: 93

(Say you have 15 items in an array. For whatever reason, such as you not being in control of the expected input structure of whatever you're giving this JSON to, you have them grouped with comments at the top of each block.)

As someone who's standing on the precipice of GHCJS, Haste and PureScript, I'm very curious to hear about your Haste experiences in this regard.

(I've been using PureScript in my side-projects for a bit. For the sake of completeness of this list, I've tried Elm and am not interested.)

(It's also a bit wobbly, which isn't great, but probably expected.)

Can be in-memory state. Everything beyond toy-sized I've ever worked on has externalised this sort of state to a database of some kind, if only so you can run a second copy for the sake of failover. I don't believe your example is relevant.

https://www.ruby-lang.org/en/news/2014/01/10/ruby-1-9-3-will...

https://www.ruby-lang.org/en/news/2015/02/23/support-for-rub...

https://docs.google.com/document/d/1soIYek-YEIvqtu9brv3ecdPb...

This page goes into a bit more detail: https://andreashead.wikispaces.com/How+Do+Blind+People+Use+a...

    $('body').append('');

As an Australian, I fear this is yet another one of those things we won't be able to use on our spotty 250KB/s connections.

I recommend having a read of this other discussion thread further up the page: https://news.ycombinator.com/item?id=8312701

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

Points: 4

# Comments: 0

It's not full-record-serialization, and it can't bring back deleted records for you.

(See https://github.com/rails/rails/tree/master/activejob#globali... for an example.)