Comment by mrkeen

HM works great for me. Let's try it elsewhere instead of blaming the algorithm!

  {-# LANGUAGE OverloadedStrings #-}          -- Let strings turn into any type defining IsString
  {-# LANGUAGE GeneralizedNewtypeDeriving #-} -- simplify/automate defining IsString 

  import Data.String (IsString)

  main = do

    -- Each of these expressions might be a String or one of the 30 Foo types below
    let address  = "127.0.0.1"
    let username = "steve"
    let password = "1234"
    let channel  = "11"

    let url = "http://" <> username 
                        <> ":"      <> password 
                        <> "@"      <> address 
                        <> "/api/"  <> channel 
                        <> "/picture" 

    print url

  newtype Foo01 = Foo01 String deriving (IsString, Show, Semigroup)
  newtype Foo02 = Foo02 String deriving (IsString, Show, Semigroup)
  -- ... eliding 27 other type definitions for the comment
  newtype Foo30 = Foo30 String deriving (IsString, Show, Semigroup)

Do we think I've captured the combinatorics well enough?

The url expression is 9 adjoining expressions, where each expression (and pair of expressions, and triplet of expressions ...) could be 1 of at least 31 types.

$ ghc --version

  The Glorious Glasgow Haskell Compilation System, version 9.0.2

$ time ghc -fforce-recomp foo.hs

  [1 of 1] Compiling Main             ( foo.hs, foo.o )
  Linking foo ...

  real    0m0.544s
  user    0m0.418s
  sys     0m0.118s

Feels more sluggish than usual, but bad combinatorics shouldn't just make it slightly slower.

I tried compiling the simplest possible program and that took `real 0m0.332s` so who knows what's going on with my setup...