data  Maybe a  =  Nothing | Just a
  deriving (Eq, Ord)

Prelude> :t Just
Just :: a -> Maybe a
Prelude> :t Nothing
Nothing :: Maybe a

def constfunc(x) :
  def f() :
    return f
    # или, для пущей уникальности - свяжем x
    return constfunc(x)
  return f

template<class T>
struct constfunc
{
  T original; // вдруг кому-то захочется таки посмотреть

  constfunc() {}
  constfunc(const T& src) : original(src) {}

  typedef constfunc result_type; // для совместимости с механизмом вывода boost::bind
  result_type operator() () const { return *this; }
};

def constfunc(x) :
  def f(p = None) :
    if p is True :
      return x
    else :
      return f
  return f

three = constfunc(3)
print three # function<.....>
print three(1)(2)(3) # function<.....>
print three(1)(2)(3)(False)(True) # 3

just    x = Just x
nothing x = Nothing

answer somehow = somehow 42
-- вывелся тип
answer :: (Num fourtytwo) => {-somehow-} (fourtytwo -> something) -> {-результат-} something

a = answer just    -- Just 42
b = answer nothing -- Nothing

c = answer Just    -- Just 42
d = answer nothing -- ошибка компиляции

f :: Int
f = 1 + (3 + 3)

Prelude> :m + Debug.Trace 
Prelude Debug.Trace> let f = 1 + (trace "called!" (3 + 3))
Prelude Debug.Trace> f
called!
7
Prelude Debug.Trace> f
7
Prelude Debug.Trace>

int hello() { printf("hello!"); return 1+3+3; }
static int const x = hello();
void suddenly()
{
  static int const y = hello();
}

SV>Мне кажется, утверждение "всё является функцией" основано на том, что такого рода сущности никак не выделены в языке. Хотя полезность такого обобщения, конечно, сомнительна (но и вреда особо не видно ).

К>int hello() { printf("hello!"); return 1+3+3; }
К>static int const x = hello();
К>void suddenly()
К>{
К>  static int const y = hello();
К>}
К>

int hello1() {return 1+3+3}
int hello2 = 7

SV>>Мне кажется, утверждение "всё является функцией" основано на том, что такого рода сущности никак не выделены в языке. Хотя полезность такого обобщения, конечно, сомнительна (но и вреда особо не видно ).

f2 a = a + 1      -- function binding
f2 = \a -> a + 1  -- pattern binding
f2 = (+1)         -- pattern binding

SV>int hello1() {return 1+3+3}
SV>int hello2 = 7
SV>

enum unit_type { the_unit };

int hello1(unit_type _) { return 7; } // подчеркнём наличие "пустого" аргумента
static lazy<int> hello2 = bind(hello1, the_unit); //

SV>f2 a = a + 1      -- function binding
SV>f2 = \a -> a + 1  -- pattern binding
SV>f2 = (+1)         -- pattern binding
SV>

SV>В первом случае f2 биндится на function value, а в двух других -- просто на value. В чём разница между value и function value? Хз, в определении языка никакой разницы я не нашёл (вполне допускаю, впрочем, что плохо искал ).

f x = x+1 -- Num a => a->a
g = (+1)  -- Integer->Integer

-- хотя можно и объявить явно
h :: (Fractional a) => a->a -- подойдёт любой субкласс Num :)
h = (+1)

i :: Int->Int -- подойдёт любой инстанс Num
i x = x+1

x = 3
y() = trace "y" `seq` 4()

f()  = x() + 1() -- (+) здесь неполноценная встроенная функция, принимающая разбоксированные значения
g(z) = f() + z() -- раз мы пользуемся (+), то вынуждены разбоксировать аргумент
h()  = g(y)      -- а здесь боксированный аргумент и разбоксированный результат