Дбрый день, товарищи!
Читаю SICP, где-то четверть уже прочитал. Вчера понял, как спомощью функций можно описывать абстракции (суммирование,перемножение->аккумуляция). Еще чуть-чуть и кажется помойму как проектировать в терминах ФП — это что уже диагноз?

Здравствуйте, mini_root_2, Вы писали:

__>Дбрый день, товарищи!
__>Читаю SICP, где-то четверть уже прочитал. Вчера понял, как спомощью функций можно описывать абстракции (суммирование,перемножение->аккумуляция). Еще чуть-чуть и кажется помойму как проектировать в терминах ФП — это что уже диагноз?

Оставайтесь на месте. За вами скоро приедут.



...Санитары

Здравствуйте, mini_root_2, Вы писали:

__>Дбрый день, товарищи!
__>Читаю SICP, где-то четверть уже прочитал. Вчера понял, как спомощью функций можно описывать абстракции (суммирование,перемножение->аккумуляция). Еще чуть-чуть и кажется помойму как проектировать в терминах ФП — это что уже диагноз?

Здорово! Ещё один выздоравливает.

Здравствуйте, mini_root_2, Вы писали:

__>Дбрый день, товарищи!
__>Читаю SICP, где-то четверть уже прочитал. Вчера понял, как спомощью функций можно описывать абстракции (суммирование,перемножение->аккумуляция). Еще чуть-чуть и кажется помойму как проектировать в терминах ФП — это что уже диагноз?

в качестве меры профилактики рекомендуется ежедневно заниматься оптимизацией программ

Здравствуйте, BulatZiganshin, Вы писали:

BZ>Здравствуйте, mini_root_2, Вы писали:

__>>Дбрый день, товарищи!
__>>Читаю SICP, где-то четверть уже прочитал. Вчера понял, как спомощью функций можно описывать абстракции (суммирование,перемножение->аккумуляция). Еще чуть-чуть и кажется помойму как проектировать в терминах ФП — это что уже диагноз?

BZ>в качестве меры профилактики рекомендуется ежедневно заниматься оптимизацией программ

И чем мне это поможет? Лучше уж писать на vba по два часа в день до полного разжижения мозга.. .

Здравствуйте, mini_root_2, Вы писали:

__>Дбрый день, товарищи!
__>Читаю SICP, где-то четверть уже прочитал. Вчера понял, как спомощью функций можно описывать абстракции (суммирование,перемножение->аккумуляция). Еще чуть-чуть и кажется помойму как проектировать в терминах ФП — это что уже диагноз?

Описывать абстракции это одно. А вот прочитывать абстракции это другое.

Вот пытался давеча такую абстракцию прочитать:

(define-syntax cond
  (lambda (x)
    (syntax-case x ()
      ((_ c1 c2 ...)
       (let f ((c1 (syntax c1)) (cmore (syntax (c2 ...))))
         (if (null? cmore)
             (syntax-case c1 (else =>)
               ((else e1 e2 ...) (syntax (begin e1 e2 ...)))
               ((e0) (syntax (let ((t e0)) (if t t))))
               ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t)))))
               ((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...)))))
             (with-syntax ((rest (f (car cmore) (cdr cmore))))
               (syntax-case c1 (=>)
                 ((e0) (syntax (let ((t e0)) (if t t rest))))
                 ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t) rest))))
                 ((e0 e1 e2 ...)
                  (syntax (if e0 (begin e1 e2 ...) rest)))))))))))

Тут одним стаканом не обойдешься. Это ж сколько стаканов нужно употребить, чтобы такое сходу прочитывать?

Здравствуйте, mini_root_2, Вы писали:

__>Дбрый день, товарищи!
__>Читаю SICP, где-то четверть уже прочитал. Вчера понял, как спомощью функций можно описывать абстракции (суммирование,перемножение->аккумуляция). Еще чуть-чуть и кажется помойму как проектировать в терминах ФП — это что уже диагноз?

Не, рано пока ставить диагноз... Ты ещё Haskell с его монадами не видел

Я тоже, когда прочитал sicp, думал, что всё теперь в ФП понимаю .

Здравствуйте, frogkiller, Вы писали:

F>Не, рано пока ставить диагноз... Ты ещё Haskell с его монадами не видел

Монады — фигня!
Достаточно вкурить в 4 разных монады — Maybe, State, List, IO — чтобы все остальные монады на одной затяжке проходили.
Maybe — самый простой контейнер (не считая Id, естественно), просто обёртка данных
State — "не просто" обёртка данных, а ещё и изменчивая среда с функциями, определёнными над ней
List — хранилище множества данных, демонстрирующее монадную арифметику во всей красе.
IO — частный случай State, чертовски защищённый от расковыривания. Что в IO попало, то пропало.

Вот когда стрелки будут не фигнёй, вот тогда точно уже диагноз.

Здравствуйте, last shinji, Вы писали.

Кстати, вот.

Два разных определения do

(define-syntax do
  (lambda (x)
    (syntax-case x ()
      ((_ (binding ...) (test res ...) exp ...)
       (with-syntax ((((var val update) ...)
                      (map (lambda (b)
                             (syntax-case b ()
                               ((var val)
                                (syntax (var val var)))
                               ((var val update)
                                (syntax (var val update)))))
                           (syntax (binding ...)))))
         (syntax (let doloop ((var val) ...)
                   (if test
                       (begin (if #f #f) res ...)
                       (begin exp ... (doloop update ...))))))))))

(define-syntax do
  (lambda (orig-x)
    (syntax-case orig-x ()
      (( ((var init . step) ... ) (e0 e1 ... ) c ... )
       (with-syntax (((step ... )
                      (map (lambda (v s)
                             (syntax-case s ()
                               (() v)
                               ((e) (syntax e))
                               ( (syntax-error orig-x))))
                           (syntax (var ... ))
                           (syntax (step ... )))))
         (syntax-case (syntax (e1 ... )) ()
           (() (syntax (let doloop ((var init) ... )
                         (if (not e0)
                             (begin c ... (doloop step ... ))))))
           ((e1 e2 ... )
            (syntax (let doloop ((var init) ... )
                      (if e0
                          (begin e1 e2 ... )
                          (begin c ... (doloop step ... ))))))))))))

Помогите, пожалуйста, понять как используюстя паттерны ((var val update) ...) и (step ... ), к ним привязывается что-то или они предварительно раскрываются?

Здравствуйте, last shinji, Вы писали:
...
Макрос — это маленький компилятор, зачастую он довольно сложно преобразует передданое в него AST.

LS>Помогите, пожалуйста, понять как используюстя паттерны ((var val update) ...) и (step ... ), к ним привязывается что-то или они предварительно раскрываются?

Намек есть вот тут: http://www.rsdn.ru/Forum/message/2233442.1.aspx

Автор: z00n
Дата: 25.11.06

А вообще нужно читать Дибвига (он, кстати, автор переносимой реализации syntax-case): http://www.scheme.com/tspl3/

BZ>>в качестве меры профилактики рекомендуется ежедневно заниматься оптимизацией программ

__>И чем мне это поможет? Лучше уж писать на vba по два часа в день до полного разжижения мозга.. .

я на днях даже от gcc плевался. представьте, себе, такой вот код:

byte *p;
x = *p/16;

он превращает в

movzl (%ebx), eax
shrb  al, 4
movzl al, eax

прям хоть ассемблерные вставки делай а вы тут — хаскел, фп, монады. эх, где мои семнадцать лет, когда у меня в программе даже sp был задействован для хранения своих данных

Здравствуйте, frogkiller, Вы писали:

F>Не, рано пока ставить диагноз... Ты ещё Haskell с его монадами не видел
F>Я тоже, когда прочитал sicp, думал, что всё теперь в ФП понимаю .

Добрый день, товарищи!

Уря! Оказывается я еще практически здоров! Вчера поставил себе немерле на моно и понял, что до настоящих извращенцев мне еще далеко (не будем показывать пальцем...). Читал статью в переводе Влада, долго думал что означает сие:

[Hygienic]
cache(e : Expr) : Expr * Expr
{ | <[ $obj.$mem ]> => (<[ def tmp = $obj ]>, <[ tmp.$mem ]>) 
  | <[ $tab [$idx] ]> => 
    (<[ def (tmp1, tmp2) = ($tab, $idx) ]>, <[ tmp1 [tmp2] ]>)
  | _ => (<[()]>, e)
}

Т.е понятно что это конструкция match/case, которая меняет местами значения двух переменных, но совершенно непонятно зачем там квази цитирование (да и вообще макросы? я видел в статье упоминание случайных элементов массива, но все равно не совсем понятно)?
P.S. Что-то меня от немерле не торкнуло — видимо надо увеличить дозу .

Здравствуйте, mini_root_2, Вы писали:

__>P.S. Что-то меня от немерле не торкнуло

Не боишся, что тебя забанят?

Здравствуйте, Andrei N.Sobchuck, Вы писали:

ANS>Не боишся, что тебя забанят?

За то что не торкнуло? Ну это поправимо, вот приду сеогдня домой — сяду писать интерпретатор брейнфака на немерле (главное догадаться куда впихнуть макросы, и вообще для чего они там нужны...).

P.S. А что на РСДН действует тайная секта немерлистов-фундаменталистов, которые банят всех кого не торкнуло после хело ворда (обязательно с использованием самопального макроса println) на немерле?

__>P.S. Что-то меня от немерле не торкнуло — видимо надо увеличить дозу .

и ждать прихода розового слоника

Здравствуйте, Кодт, Вы писали:

К>Монады — фигня!
К>Достаточно вкурить в 4 разных монады — Maybe, State, List, IO — чтобы все остальные монады на одной затяжке проходили.
К>Maybe — самый простой контейнер (не считая Id, естественно), просто обёртка данных
К>State — "не просто" обёртка данных, а ещё и изменчивая среда с функциями, определёнными над ней
К>List — хранилище множества данных, демонстрирующее монадную арифметику во всей красе.
К>IO — частный случай State, чертовски защищённый от расковыривания. Что в IO попало, то пропало.

Мне как прожжёному императивщику даже эти 4 монады кажутся сильно страшными. Единственный лучик света, что я пока встречал — статья в LinuxJournal.

Там, в частности, рассмотрена упомянутая тобой Maybe. Правда реализованная на не совсем императивных языках, в которых имеются замыкания. Я тут попробовал переписать этот пример на С++, получилось так:

#include <iostream>

template <typename TValue, class TInstance>
struct CMonadDef
{
    struct CMyFunctor
    {
        virtual TInstance apply(const TValue &) = 0;
    };
};

template <typename TValue, class TInstance>
class CMonad
{
protected:
    TValue m_value;    
    CMonad() {}

public:
    CMonad(const TValue &_value) : m_value(_value) {}

    typedef typename CMonadDef<TValue, TInstance>::CMyFunctor CMyFunctor;
    typedef TValue TVal;

    virtual TInstance pass(CMyFunctor * pfn)
    {
        return pfn->apply(m_value);
    }
};

template <typename T, class TInstance>
class CMaybe : public CMonad<T, TInstance>
{
    bool m_bNone;

public:
    struct None {};
    static None & getNone()
    {
        static None none;
        return none;
    }

    typedef CMonad<T, TInstance> IParent;

    CMaybe(const T &_value) : IParent(_value), m_bNone(false) {}
    CMaybe(const None &) : m_bNone(true) {}

    virtual TInstance pass(typename IParent::CMyFunctor * pfn)
    {
        if (m_bNone)
        {
            return TInstance(getNone());
        }
        return IParent::pass(pfn);
    }

    void Print() const
    {
        if (m_bNone)
        {
            std::cout << "Maybe(none)" << std::endl;
        }
        else
        {
            std::cout << "Maybe(" << this->m_value << ")" << std::endl;
        }
    }
};

template <typename T, class TMonad>
struct IArithmetic
{
    class CAddFunctor : public TMonad::CMyFunctor
    {
        const T &m_value;
    public:
        CAddFunctor(const T &_value) : m_value(_value) {}
        virtual TMonad apply(const T &_value)
        {
            return TMonad(m_value + _value);
        }
    };
    template <class CApplication, class TAnotherMonad>
    class CMyBinder : public TAnotherMonad::CMyFunctor
    {
        TAnotherMonad &m_value;
    public:
        CMyBinder(TAnotherMonad &_value) : m_value(_value) {}
        virtual TAnotherMonad apply(const typename TAnotherMonad::TVal &_value)
        {
            CApplication app(_value);
            return m_value.pass(&app);
        }
    };

    template <class TAnotherMonad>
    TMonad Add(TAnotherMonad &rhs)
    {
        CMyBinder<CAddFunctor, TAnotherMonad> app(rhs);
        return static_cast<TMonad*>(this)->pass(&app);
    }

    template <class TAnotherMonad>
    friend TMonad operator+ (TMonad &lhs, TAnotherMonad &rhs)
    {
        return lhs.Add(rhs);
    }
};

template <typename T>
struct CArithmeticMaybe : public CMaybe<T, CArithmeticMaybe<T> >, public IArithmetic<T, CArithmeticMaybe<T> >
{
    typedef CMaybe<T, CArithmeticMaybe<T> > CMaybeParent;
    CArithmeticMaybe(const typename CMaybeParent::None &none) : CMaybeParent(none) {}
    CArithmeticMaybe(const T &_value) : CMaybeParent(_value) {}
};

CArithmeticMaybe<int> n1(5), n2(6), n3(CArithmeticMaybe<int>::getNone());

int main(int argc, char* argv[])
{
    n1.Add(n2).Add(n2).Print();
    n1.Add(n2).Add(n3).Print();

    //(n2 + (CArithmeticMaybe<int>)2).Print();
    //((CArithmeticMaybe<int>)CArithmeticMaybe<int>::getNone() + n2).Print();
    return 0;
}

Собственно, я тоже посупил не совсем честно, используя шаблоны, но без них, боюсь, не обойтись. Вот так императивщик воспринимает монады, правда страшно? Как будет выглядеть IO я и подумать-то боюсь...

Оффтоп, вопросы (их, возможно, следовало бы запостить с Cpp):
1. Как бы это хозяйство (ручной бинд функторов в IArithmetic) переписать с помощью boost::lambda? Я в бусте совсем слаб, и все мои попытки что-то использовать оттуда при написании вышеприведённого кода выглядели каким-то шаманством, которое так ни к чему и не привело.

2. Почему не проходит неявное преобразование в двух закомментированных строчках? Я сначала подумал, что это глюк моего MSVC7.1, но Comeau Online тоже они не понравились, он ругается даже на явный каст.

Здравствуйте, frogkiller, Вы писали:

F>Здравствуйте, Кодт, Вы писали:

К>>Монады — фигня!
К>>Достаточно вкурить в 4 разных монады — Maybe, State, List, IO — чтобы все остальные монады на одной затяжке проходили.
К>>Maybe — самый простой контейнер (не считая Id, естественно), просто обёртка данных
К>>State — "не просто" обёртка данных, а ещё и изменчивая среда с функциями, определёнными над ней
К>>List — хранилище множества данных, демонстрирующее монадную арифметику во всей красе.
К>>IO — частный случай State, чертовски защищённый от расковыривания. Что в IO попало, то пропало.

F>Мне как прожжёному императивщику даже эти 4 монады кажутся сильно страшными. Единственный лучик света, что я пока встречал — статья в LinuxJournal.

А можно глупый вопрос? Что такое монады и зачем они вообще нужны?
P.S. Можно смело продолжать читать SICP — до настоящих функциональных извращенцев мне еще далеко ...

Здравствуйте, mini_root_2, Вы писали:

__>P.S. А что на РСДН действует тайная секта немерлистов-фундаменталистов, которые банят всех кого не торкнуло после хело ворда (обязательно с использованием самопального макроса println) на немерле?
И банят не тех, кого не торкнуло, а тех, кто занимается неконструктивной критикой Немерла.

__>А можно глупый вопрос? Что такое монады и зачем они вообще нужны?

насколько я в курсе, по ним написано 666 руководств, и всё равно учёные ещё не разобрались до конца

http://www.haskell.org/haskellwiki/Learning_Haskell ищи Monads

Здравствуйте, Блудов Павел, Вы писали:

БП>Здравствуйте, mini_root_2, Вы писали:

__>>P.S. А что на РСДН действует тайная секта немерлистов-фундаменталистов, которые банят всех кого не торкнуло после хело ворда (обязательно с использованием самопального макроса println) на немерле?
БП>И банят не тех, кого не торкнуло, а тех, кто занимается неконструктивной критикой Немерла.

Ой, надо же, это же в корне все меняет. Какие эти баньшики оказывается, адекватные и спокойные люди.

Эрланг — говно тормозное. Ну? Кто бежит меня арестоффать? Эй, Мамут? Ты там как, нормально пережил неконструктивную критику?