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)      -- а здесь боксированный аргумент и разбоксированный результат

{-# LANGUAGE NoMonomorphismRestriction  #-}

import Debug.Trace

f = 1 + (trace "called!" (3 + 3))

g = (f,f)

*Main> g
(called!
7,called!
7)

alwaysThree = const 3
three = alwaysThree undefined -- на входе _|_ как типичный представитель универсума, на выходе - всё равно 3
main = putStrLn $ show three

U>зы: короче, я не разделяю попытку отказаться от чисел в пользу функций

cToInt a = a (+1) 0
cInc c = (\f -> f . (c f))

snd3 (_, b, _) = b

cDec c = (\f -> snd3 $ (c g) (f, id, False))
  where g (f, x, True) = (f, f . x, True)
        g (f, x, False) = (f, x, True)

U>cToInt a = a (+1) 0

U>cInc c = (\f -> f . (c f))

cInc c = \f -> (c f) . f

U>snd3 (_, b, _) = b

U>cDec c = (\f -> snd3 $ (c g) (f, id, False))
U>  where g (f, x, True) = (f, f . x, True)
U>        g (f, x, False) = (f, x, True)
U>

cDec c = \f x -> finish $ c (step f) (start x) where
  start x = (error "вычитание из нуля!!!", x)
  step f (decx, x) = (x, f x)
  finish (decx, x) = decx

U>где можно почитать про SKI и S ?

U>>snd3 (_, b, _) = b

U>>cDec c = (\f -> snd3 $ (c g) (f, id, False))
U>>  where g (f, x, True) = (f, f . x, True)
U>>        g (f, x, False) = (f, x, True)
U>>

К>cDec c = \f x -> finish $ c (step f) (start x) where
К>  start x = (error "вычитание из нуля!!!", x)
К>  step f (decx, x) = (x, f x)
К>  finish (decx, x) = decx
К>

-- нам нужно:
pair x y = \selector -> .....
fst xy = xy fst' where fst' = .....
snd xy = xy snd' where snd' = .....

-- чёрчева логика
CBool :: {-then-} a -> {-else-} a -> {-result-} a
true_  t e = t
false_ t e = e

if_ c t e = c t e
and_ a b  = a b false_
or_  a b  = a true_ b
not_ a    = a false_ true_
-- и т.д.

-- реализуем
pair x y = \selector -> selector x y
fst xy = xy true_
snd xy = xy false_

-- подставляем
cDec c f x = finish $ c step f $ start where
  start     = pair (error "-1") x
  step xy   = pair (snd xy) (f $ snd xy)
  finish xy = fst xy

Input Functions These functions read input from the standard input device (normally the user’s terminal).
  getChar     :: IO Char  
  getLine     :: IO String  
  getContents :: IO String  
  interact    :: (String -> String) -> IO ()  
  readIO      :: Read a => String -> IO a  
  readLn      :: Read a => IO a

SV>Input Functions These functions read input from the standard input device (normally the user’s terminal).
SV>  getChar     :: IO Char  
SV>  getLine     :: IO String  
SV>  getContents :: IO String  
SV>  interact    :: (String -> String) -> IO ()  
SV>  readIO      :: Read a => String -> IO a  
SV>  readLn      :: Read a => IO a
SV>

constIO :: x -> IO x
constIO x = return x

type Call x = () -> x

constCall :: x -> Call x
constCall x = const x

SV>>Определить действие через монады, очевидно, не получится. Более того, за десять минут я не придумал ни одного вменяемого способа определить понятие "действие". Если ты знаешь такой способ -- делись

f :: Monad m => m Int
f = return 1

g1 :: IO Int
g1 = do
  a <- f
  return $ a + 1

g2 :: [Int]
g2 = do
  a <- f
  return $ a + 1

SV>f :: Monad m => m Int
SV>f = return 1

SV>g1 :: IO Int
SV>g1 = do
SV>  a <- f
SV>  return $ a + 1

SV>g2 :: [Int]
SV>g2 = do
SV>  a <- f
SV>  return $ a + 1
SV>

import Control.Applicative

f :: Applicative f => f Int
f = pure 1

g1 :: Maybe Int
g1 = f

g2 :: Int -> Int
g2 = f