Pain Points of Haskell

Post by lmm » Tue, Jun 09, 2020, 12:47 AM UTC

pdimitar wrote: post #242

tathougies wrote: post #226

Earlier quoted context omitted.

> (several types of them). I find this criticism very bizarre. C++ and C have several different string types, as does python. This comes down to the fact that what programmers think are strings are often not really and vice versa. To be clear, a 'string' is a sequence of characters or glyphs meant for human consumption or that are produced by a human as input. A string is not a sequence of bytes. C++ and C get this r…

You might find this a bizarre criticism but In Java, Ruby, Elixir, Rust strings are all Unicode with escape hatches for manually handling byte arrays (that could be C strings). In that regard I still find it extremely puzzling that some languages / runtimes still struggle with only giving you two choices: byte arrays and UTF-8 strings. I really don't know what's so hard about it. As mentioned in another comment in th…

Post by lmm » Tue, Jun 09, 2020, 1:10 AM UTC

misja111 wrote: post #246

johnday wrote: post #198

Earlier quoted context omitted.

I firmly believe that monads (and monad transformers) are exactly what an industrial engineer needs, for the following important reason. A monad describes its scope in such a way that writing code outside of its scope is a compile time error. If your code needs certain capabilities, it must invoke the computational context of those capabilities (which is usually a monad in Haskell). If it doesn't, then the context ca…

Even if you have separated concerns by having method 1 return Monad transformer A and method 2 return transformer B, you will still have to combine the results of both your methods at some point.

Post by lmm » Tue, Jun 09, 2020, 1:34 AM UTC

gavinray wrote: post #247

jackcviers3 wrote: post #212

Earlier quoted context omitted.

The reply by louthy is great, but it doesn't answer your first question: > What is referential transparency? A function reference that can be replaced at all call sites in a program with its body with all of the references to its arguments replaced with references to the call site arguments without the observable behavior of the program changing is referentially transparent. In practice, it means that you can safely…

Monad is really just "flatMap"? Is this basically it then: interface Monad { flatMap: (arg: Some ) => Maybe } let userAges: Monad.flatMap = flatMap (users, user => user.age)

    interface Monad> {
      fun flatMap(argument: F, function: A -> F): F
      // also need pure/point here but ignore that for now
    }

    singleton OptionMonad implements Monad
      override fun flatMap(argument: Option, function: A -> Option): Option =
        when(argument) {
          is Some -> function(argument.value)
          is None -> None
        }

    singleton FutureMonad implements Monad {
      override fun flatMap(argument: Future, function: A -> Future): Future = ...
    }