CODEWITHSUNDEEP
haskelltypesdeclaration
EFTH
EFTH

Reputation: 475

Haskell - Declaring the type of multiple functions

I often find myself writing multiple functions with the same type. Let's call this type FuncType. I might write something like this:

funcA :: FuncType
funcB :: FuncType
funcC :: FuncType
funcD :: FuncType

-- Implementations

This feels like a lot of unnecessary typing (typing as in tapping on the keyboard, not declaring types of functions). Is there maybe some way to do this more concisely? What I want would look something along the lines of:

(funcA, funcB, funcC, funcD) :: FuncType

-- Implementations

I really tried to google this but I came up empty. If this isn't a feature of the language, why not? Am I missing something? Am I doing something wrong if I find myself needing this?

Upvotes: 13

Views: 1185

Answers (2)

Toxaris
Toxaris

Reputation: 7266

Alternatively to MasterMastic's answer, you can also actually give the repeated type a name using a type declaration:

-- | why GoodName is a good name
type GoodName = Complicated -> Function -> Type

-- | Foo explanation.
foo :: GoodName
foo = ...

-- | Bar explanation.
bar :: GoodName
bar = ...

This way, you only need to repeat the name instead of the potentially much longer type. Benefits of this style over foo, bar :: Complicated -> Function -> Type include:

  • the named type serves as documentation
  • the named type can be reused elsewhere
  • the function definitions and type signatures are next to each other
  • you can have different haddock comments for the different functions
  • your source code looks more regular
  • if only one of the functions later gets refactored to take additional arguments, the change is more local.

Of course, you can also combine these approaches as foo, bar :: GoodName. Because of type inference, you can usually even leave out the type signature altogether and let the compiler figure out the type.

Upvotes: 4

MasterMastic
MasterMastic

Reputation: 21306

Do what you tried without the parentheses.

funcA, funcB, funcC, funcD :: FuncType

In the Haskell 2010 report, you can see in chapter 4 (Declarations and Bindings) that a type signature (gendecl) looks like this:

vars :: [context =>] type

and vars look like this:

var-1 , … , var-n

Which is exactly the form you're looking for.

Sidenote: Haddock will apply a documentation if it finds it around that type signature to every symbol in that (vars) list.

Upvotes: 18

Related Questions