It’s implemented underneath with an HAMT (hash array mapped trie) iirc. So although it compares on hashes it’s an ordered map over those hashes w/ O(log n) for most ops.

What use of the C preprocessor are you seeing? Is it the #include? That does work like C’s #include but there are more module like things. See staload. These respect namespacing and local definitions so you can do things like:

local
  staload FOO = "somefile.sats"
in
  $FOO.dosomething()
end

I remember wanting this feature well before 1.0.

Those are really great questions.

… is that generally not a problem encountered with monads?

That’s the point of monads, code reuse. I personally write a lot of code which works over many monads or all monads. One example I have from about 2 weeks ago:

whileM_ :: (Monad m) => m Bool -> m a -> m ()
whileM_ cond ma = do
 b <- cond
 when b $ ma *> whileM_ cond ma

This function allows looping over any monadic value. Works for values which represents state, configuration, IO, etc.

The example you copied uses print, I don’t know the imports but I’m guessing it’s the one from Prelude which has type (Show a) => a -> IO (). My manual type inference in my head says the example is using IO:

program :: IO ()
program = do
  a <- getData
  b <- getMoreData a
  c <- getMoreData b
  d <- getEvenMoreData a c
  print d

But let’s say you use some other print function, maybe one which changes the specific IO type into a constraint, so I can use it over any monad which supports IO:

program :: (MonadIO m) => m ()
program = do
  a <- getData
  b <- getMoreData a
  c <- getMoreData b
  d <- getEvenMoreData a c
  print d

But let’s also say that getData now has a different constraint. It does some stuff with configuration:

program :: (MonadIO m, MonadReader MyConfig m) => m ()
program = do
  a <- getData
  b <- getMoreData a
  c <- getMoreData b
  d <- getEvenMoreData a c
  print d

And now getEvenMoreData actually does some stuff with state:

program :: (MonadIO m, MonadReader MyConfig m, MonadState MyState m) => m ()
program = do
  a <- getData
  b <- getMoreData a
  c <- getMoreData b
  d <- getEvenMoreData a c
  print d

But this program is polymorphic. It can be instantiated as a monadic value, as long as it supports IO, Reader and State. A common use of this is to have one instantiation for production and one instantiation for tests. Yay, code reuse!!!

So the answer to your question:

How do I tell whether that is a maybe monad, a list monad, a continuation monad, or a state monad?

Is that you read the types.

By type signatures. Or, if you’ve got monad-specific functions mixed in like State‘s get and put, then it becomes fairly obvious what sort of monad you’re dealing with. The code shown in the article could even be polymorphic w.r.t. the monad - assuming getData and co. are too.

I tend to use monads for “secondary” concerns - the kind of thing that I would consider leaving completely invisible if I were working in a language without monads. E.g. if working with state is the whole point of a given function then I’d probably have it accept and return the state in question rather than passing it via a state monad. So the <- just indicates “a secondary effect is going on here”, and if I wanted to know the specifics I’d mouse over one of the functions and see what the type signature is.

But yeah in code that mixes multiple monads there are cases where it would be nicer to have a way to distinguish. I wonder about an IDE using e.g. colour or underlines to show what monads were in play.

I think there is a typo in the “The Bad: Type Inference” section. As written, it is:

val nums4: List[Double] = List(1, 2, 3) // compiles

val nums5a = List(1, 2, 3)
val nums5b: List[Double] = nums4         // fails to compile

I believe it probably should have been

val nums4: List[Double] = List(1, 2, 3) // compiles

val nums5a = List(1, 2, 3)
val nums5b: List[Double] = nums5a         // fails to compile

or else I don’t know what nums5a is supposed to be there for.

Looks like a typo here: “In response, it was tried to put band-aid around it.”