Lambda for type expressions in Haskell?

by

While sclv answered your direct question, I’ll add as an aside that there’s more than one possible meaning for “type-level lambda”. Haskell has a variety of type operators but none really behave as proper lambdas:

  • Type constructors: Abstract type operators that introduce new types. Given a type A and a type constructor F, the function application F A is also a type but carries no further (type level) information than “this is F applied to A“.
  • Polymorphic types: A type like a -> b -> a implicitly means forall a b. a -> b -> a. The forall binds the type variables within its scope, thus behaving somewhat like a lambda. If memory serves me this is roughly the “capital lambda” in System F.
  • Type synonyms: A limited form of type operators that must be fully applied, and can produce only base types and type constructors.
  • Type classes: Essentially functions from types/type constructors to values, with the ability to inspect the type argument (i.e., by pattern matching on type constructors in roughly the same way that regular functions pattern match on data constructors) and serving to define a membership predicate on types. These behave more like a regular function in some ways, but are very limited: type classes aren’t first-class entities that can be manipulated, and they operate on types only as input (not output) and values only as output (definitely not input).
  • Functional dependencies: Along with some other extensions, these allow type classes to implicitly produce types as results as well, which can then be used as the parameters to other type classes. Still very limited, e.g. by being unable to take other type classes as arguments.
  • Type families: An alternate approach to what functional dependencies do; they allow functions on types to be defined in a manner that looks much closer to regular value-level functions. The usual restrictions still apply, however.

Other extensions relax some of the restrictions mentioned, or provide partial workarounds (see also: Oleg’s type hackery). However, pretty much the one thing you can’t do anywhere in any way is exactly what you were asking about, namely introduce new a binding scope with an anonymous function abstraction.

More Related Contents:

  1. How to compare two functions for equivalence, as in (λx.2*x) == (λx.x+x)?
  2. How to compare two functions for extensional equivalence, as in (λx.2*x) == (λx.x+x)?
  3. Why give me error? [closed]
  4. Good examples of Not a Functor/Functor/Applicative/Monad?
  5. Defining a function by equations with different number of arguments
  6. :sprint for polymorphic values?
  7. Small Haskell program compiled with GHC into huge binary
  8. Writing foldl using foldr
  9. DatatypeContexts Deprecated in Latest GHC: Why?
  10. Haskell function composition operator of type (c→d) → (a→b→c) → (a→b→d)
  11. Unwrapping a monad
  12. What are “n+k patterns” and why are they banned from Haskell 2010?
  13. How do I write, “if typeclass a, then a is also an instance of b by this definition.”
  14. Haskell read raw keyboard input
  15. Currying 3 Arguments in Haskell
  16. Expressing do block using only monadic bind syntax
  17. Why do we need monads?
  18. What constitutes a fold for types other than list?
  19. Defining a new monad in haskell raises no instance for Applicative
  20. What are Alternative’s “some” and “many” useful for?
  21. Typeclass constraints on data declarations
  22. What does the `forall` keyword in Haskell/GHC do?
  23. How does deriving work in Haskell?
  24. What characters are permitted for Haskell operators?
  25. Converting IO Int to Int
  26. Convert String to Integer/Float in Haskell?
  27. Haskell – depth for each node in binary tree using Reader monad
  28. Functional lenses
  29. How to reuse a type variable in an inner type declaration
  30. How does Haskell printf work?

Leave a Comment