Breaking type signatures across multiple lines

[garyb]

If you're going to do this to prevent excessively long lines, do it like this:

logShow
  :: forall a eff
   . Show a 
  => a 
  -> Eff (console :: CONSOLE | eff) Unit

So the type starts indented on the next line and each line starts with the symbol.

Unicode version:

logShow
  ∷ ∀ a eff
  . Show a 
  ⇒ a 
  → Eff (console :: CONSOLE | eff) Unit
logShow a = log (show a)

[LiamGoodacre]

Alternative?:

logShow :: forall a eff. Show a =>
  a -> Eff (console :: CONSOLE | eff) Unit

dimap :: forall p a b c d. Profunctor p =>
  (b -> a) -> (c -> d) -> p a c -> p b d

traverse :: forall t m a b.
  (Traversable t, Applicative m) =>
  (a -> m b) -> t a -> m (t b)

[nwolverson]

I find @garyb's version really hard to read. Perhaps that is a particularly bad example, just seems to break all visual flow. (also suffers from purescript-contrib/atom-language-purescript#22 as we see above)

@LiamGoodacre's alternative seems much more readable to me - personally I just break before any ->(and thereafter on every one).

[garyb]

Heh, I find the opposite, and would say Liam's is much harder to read as you need to scan backwards and forwards a lot to work out where the constraints end and so on. I would at least suggest the "starting line with a symbol" is pretty important, as you immediately know whether you are reading constraints or not then:

logShow 
  :: forall a eff. Show a 
  => a -> Eff (console :: CONSOLE | eff) Unit

dimap 
  :: forall p a b c d. Profunctor p 
  => (b -> a) -> (c -> d) -> p a c -> p b d

traverse 
  :: forall t m a b
   . (Traversable t, Applicative m) 
  => (a -> m b) -> t a -> m (t b)

In the example I posted each "atom" of the type is on a new line, so it should be simpler to follow too, as you can see the arity clearly from the number of lines involved (and if you wanted to you can add comments after each argument) - and when you have a super long type it doesn't split it in arbitrary places.

It also plays well with doing this kind of thing:

producer
  :: forall f g eff p
   . SCR.StallingProducer 
      (ParentF f g (Aff (HalogenEffects eff)) p Unit) 
      (Aff (HalogenEffects eff)) 
      Unit

Which is horrible, but it's better than having it all on one line 😉

edit: but yes, the logShow example is not great, as that type's short enough that I wouldn't wrap it anyway, it's more for thing like:

evalPF
  :: forall s f g eff p
   . AVar (DriverState s f g eff p)
  -> AVar (Maybe RenderPending)
  -> ParentF f g (Aff (HalogenEffects eff)) p
  ~> Aff (HalogenEffects eff)

[garyb]

Thinking a bit more about it, I think as long as the symbol-at-start-of-line thing is done then that's probably the important part, breaking each part onto separate lines is optional after that. I'll continue to do so personally, as that's how we've settled on doing so in the SlamData codebases, but it's that thing of having to scan for the end of the constraints that bothers me about other styles of wrapped type signatures.

[LiamGoodacre]

This style doesn't prevent formatting individual components:

producer :: forall a b c x y z f g eff p.
  a b c -> x y z ->
  SCR.StallingProducer 
    (ParentF f g (Aff (HalogenEffects eff)) p Unit) 
    (Aff (HalogenEffects eff)) 
    Unit ->
  a b c -> x y z

That little offset dot in all your examples makes me feel uneasy aha 😄 - may require special editor support to make it not annoying to write.

TBH they really aren't all that different - they are equally readable in the sense that people will easily get used to which ever one is picked.

[LiamGoodacre]

@garyb

... but it's that thing of having to scan for the end of the constraints that bothers me about other styles of wrapped type signatures.

You have to do that on non-wrapped lines already.

[LiamGoodacre]

I've also put constraints across multiple lines before - with export-style syntax:

traverseDefault :: forall t m a b.
  ( Witherable t
  , Applicative m
  ) => (a -> m b) -> t a -> m (t b)
traverseDefault f = wither (map Just <<< f)