instance Monad (State s) where
    return a = State dontChangeStateAndReturnA
        where dontChangeStateAndReturnA s = (a, s)

    -- r1 :: State s a = State (s -> (a, s)) - это вычисление с состоянием
    -- p :: a -> State s b = a -> State (s -> (b, s)) - это вычисление 
    -- с состоянием, зависящее от параметра, вычисляемого r1.
    (State r1) >>= p = State passState
        where passState s = (res2, finalState)
                      -- Запускаем первое вычисление, получаем параметр
                where (res1, intermediateState) = r1 s          
                      -- Вычисляем по параметру второе вычисление
                      (State r2) = p res1                       
                      -- Запускаем второе вычисление
                      (res2, finalState) = r2 intermediateState

data SM a = SM (S -> (a,S)) -- Монадический тип

instance Monad SM where
   -- определяет распространение состояния
   SM c1 >>= fc2        = SM (\s0 -> let (r,s1) = c1 s0
                                         SM c2 = fc2 r in
                                        c2 s1)
   return k             = SM (\s -> (k,s))

printBy4 (a:b:c:d:xs) = hexChar [a,b,c,d]++printBy4 xs
printBy4 _ = ""

A>Что знают другие чего не знаю я?

A>Что знают другие чего не знаю я?

instance Monad (State s) where 
 return a = State $ \s -> (a, s) 
 m >>= k  = State $ \s -> let 
              (a, s') = runState m s 
              in runState (k a) s'

callCC :: ((a -> m b) -> m a) -> m a

(lambda (a r) (max a r))

D>>instance Monad (State s) where 
D>> return a = State $ \s -> (a, s) 
D>> m >>= k  = State $ \s -> let 
D>>              (a, s') = runState m s 
D>>              in runState (k a) s'
D>>

newtype Kleisli m a b = Kleisli {
   runKleisli :: a -> m b
}

A>но буквы то все равно выбираются осознано . Вряд ли бы Вынаписали так:

(lambda (a r) (max a r))

instance Functor ((,) x) where fmap f (a, r) = (a, f r)

type NameOfFoo = String
type TypeOfFoo = String
type FooID = Int
foo :: NameOfFoo -> TypeOfFoo -> [FooID]

foo :: (fooName :: String) -> (fooType :: String) -> (fooIDs :: [Int])

VE>foo :: (fooName :: String) -> (fooType :: String) -> (fooIDs :: [Int])
VE>

foo :: {- fooName :: -} String -> {- fooType :: -} String -> {- fooIDs :: -} [Int]

D>foo :: {- fooName :: -} String -> {- fooType :: -} String -> {- fooIDs :: -} [Int]
D>

D>

foo ::
     String -- ^ name
  -> String -- ^ type
  -> [Int]  -- ^ IDs