30

Does Haskell, or a specific compiler, have anything like type-level lambdas (if that's even a term)?

To elaborate, say I have a parametrized type Foo a b and want Foo _ b to be an instance of, say, Functor. Is there any mechanism that would let me do something akin to

instance Functor (\a -> Foo a b) where
...

?

gspr
  • 11,144
  • 3
  • 41
  • 74

7 Answers7

27

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.

C. A. McCann
  • 76,893
  • 19
  • 209
  • 302
  • isn't a data declaration for a polymorphic type, something that define a type lamda anyway, especially when using the GADT Syntax, the type variable in the header have so scope, so `data Foo a b where ...` is actually defining the type lamda [a, b] => F[A,B] using scala 3 syntax here. But in haskell something of Kind * -> * -> * is a type lamda after all. it is just that there is no named type variable at the kind level. – MaatDeamon Mar 22 '22 at 13:56
20

From TypeCompose:

newtype Flip (~>) b a = Flip { unFlip :: a ~> b }

http://hackage.haskell.org/packages/archive/TypeCompose/0.6.3/doc/html/Control-Compose.html#t:Flip

Also, if something is a Functor in two arguments, you can make it a bifunctor:

http://hackage.haskell.org/packages/archive/category-extras/0.44.4/doc/html/Control-Bifunctor.html

(or, in a later category-extras, a more general version: http://hackage.haskell.org/packages/archive/category-extras/0.53.5/doc/html/Control-Functor.html#t:Bifunctor)

sclv
  • 38,665
  • 7
  • 99
  • 204
7

I don't like the idea of answering my own question, but apparently, according to several people on #haskell on Freenode, Haskell doesn't have type-level lambdas.

gspr
  • 11,144
  • 3
  • 41
  • 74
  • 7
    They're present in the System F(c) that Haskell compiles too, but are not visible to the user, other than indirectly. – Don Stewart Nov 01 '10 at 15:29
  • 4
    "System F(c) that Haskell compiles to". That GHC compiles to. – wnoise Nov 01 '10 at 18:20
  • 2
    Don is right in that System F_c sports type level functions. However, they are always non-parametric, meaning that these functions are always defined by doing case analysis on their arguments. System F_c cannot express the code in the question above because the function in the instance is parametric. – svenningsson Nov 02 '10 at 10:36
6

EHC (and perhaps also its successor, UHC) has type-level lambdas, but they are undocumented and not as powerful as in a dependently-typed language. I recommend you use a dependently-typed language such as Agda (similar to Haskell) or Coq (different, but still pure functional at its core, and can be interpreted and compiled either lazily or strictly!) But I'm biased towards such languages, and this is probably 100x overkill for what you are asking for here!

Robin Green
  • 32,079
  • 16
  • 104
  • 187
2

The closest I know of to get a type lambda is by defining a type synonym. In your example,

data Foo a b = Foo a b

type FooR a b = Foo b a

instance Functor (FooR Int) where
...

But even with -XTypeSynonymInstances -XFlexibleInstances this doesn't work; GHC expects the type syn to be fully applied in the instance head. There may be some way to arrange it with type families.

Chris Smith
  • 5,326
  • 29
  • 29
1

Yeah, what Gabe said, which is somewhat answered by type families:

http://www.haskell.org/haskellwiki/GHC/Type_families

none
  • 19
  • 1
1

Depending on the situation, you could replace your original type definition with a "flipped" version, and then make a type synonym for the "correct" version.

From

data X a b = Y a b

instance Functor (\a -> X a b) where ...

to

data XFlip b a = Y a b  -- Use me for instance decalarations
type X a b = XFlip b a  -- Use me for everything else

instance Functor XFlip where ...
Quelklef
  • 1,999
  • 2
  • 22
  • 37