Three Months of Go from a Haskeller’s perspective (2016)

I'm not talking about the HTTP package itself. In Java and C# you do something along the lines of

  // Java
  CompletableFuture> getContracts(...);
  CompletableFuture> getClients...(...);
  CompletableFuture> getBooks...(...);

  // C#

  JsonSerializer.Deserialize>(responseBody);
  JsonSerializer.Deserialize>(responseBody);
  JsonSerializer.Deserialize>(responseBody);

  // Go
  
  type ContractsResult struct {
 Result        []*entities.Contract
 NextPageToken string
  }
  type ClientsResult struct {
 Result        []*entities.Client
 NextPageToken string
  }
  type BooksResult struct {
 Result        []*entities.Book
 NextPageToken string
  }

Code generators are just bandaid for glaring holes in the language. Worse still, I don't know if you can even specify code generating tools in your go.mod. For example, wire's installation instructions say "you need to install wire globally and have it on your $GOPATH" [1] So your go build will just fail mysteriously until you have all the necessary tools installed.

> Of course, anything more advanced would be greatly helped with generics

That... that is exactly what I'm talking about.

> Option types to avoid nil, Either types to replace the value/error tuples

Indeed. I forgot about those :) Yup, that would be a great use case for generics.

[1] https://github.com/google/wire

To elaborate this point I'd say that the most important practical use of all that "monad mumbo-jumbo" in Haskell is that you can tag your functions with what they can and can't do and then the type system tracks this for you:

  -- pure function
  f1 :: Text -> Int

  -- can fail
  f2 :: Text -> Maybe Int

  -- can read from some MyEnv record
  f3 :: Text -> Reader MyEnv Int 

  -- can keep a set of bool as state around
  f4 :: Text -> State (Set Bool) Int

  -- can do anything
  f5 :: Text -> IO Int

Also we don't have to stop here. A natural next step is defining exact effects one is after. For example say I want my function to be able to get some entity from a DB:

  -- any type that is an instance of Entity can identify itself by uuid
  class Entity e where
    identify :: e -> UUID

  -- The effect we want, ie. get an entity via its uuid
  class (Monad m, Entity e) => GetEntity e m where
    getEntityById :: UUID -> m (Maybe e)

  data User = MkUser {uId :: UUID, uName :: Text}

  -- a User can identify itself
  instance Entity User where
    identify = uId

  -- as User is an Entity so we can get it via its uuid (if it exists)
  getUserById :: (GetEntity User m) => UUID -> m (Maybe User)
  getUserById = getEntityById

  newtype Prod a = MkProd {unProd :: ReaderT ProdDB IO a}
    deriving newtype (Functor, Applicative, Monad, MonadReader ProdDB, MonadIO)

  -- get a user from a DB for real
  instance GetEntity User Prod where
    getEntityById :: UUID -> Prod (Maybe User)
    getEntityById eid = do
      ProdDB {..} 

  newtype Mock a = MkMock {unMock :: State (Map UUID User) a}
    deriving newtype (Functor, Applicative, Monad, MonadState (Map UUID User))

  -- get a user from a mock DB
  instance GetEntity User Mock where
    getEntityById :: UUID -> Mock (Maybe User)
    getEntityById eid = gets (Map.lookup eid)