На главную Наши проекты:
Журнал   ·   Discuz!ML   ·   Wiki   ·   DRKB   ·   Помощь проекту
ПРАВИЛА FAQ Помощь Участники Календарь Избранное RSS

Поздравляем всех студентов и Татьян с Татьяниным днём!




msm.ru
! Правила раздела:
1. Название темы - краткое описание кто/что против кого/чего
2. В первом сообщении - список параметров, по которым идет сравнение.
3. Старайтесь аргументировать свои высказывания. Фразы типа "Венда/Слюникс - ацтой" считаются флудом.
4. Давайте жить дружно и не доводить обсуждение до маразма и личных оскорблений.
Модераторы: Модераторы, Комодераторы
Страницы: (11) « Первая ... 9 10 [11]  все  ( Перейти к последнему сообщению )  
> Что делать с жунами , Что делать с жунами
    Цитата D_KEY @
    Но ты убери синтаксический сахар из кода и посмотри, каким образом эта зависимость выражается на самом деле.
    Да ваще, код поменялся до неузнаваемости:
    ExpandedWrap disabled
      main =
          putStrLn "str1" >>
          putStrLn "str2"


    Добавлено
    Кстати в Erlang/Elixir нет мутабельных переменных, но полно функций с побочными эффектами. Значит таки можно писать императивно (по вашему определению) без мутабельных переменных?
    Сообщение отредактировано: applegame -
      applegame,

      ExpandedWrap disabled
        main = myMain $ do
          myPutStrLn "first"
          myPutStrLn "second"
          myPutStrLn "third"


      ExpandedWrap disabled
        third
        second
        first


      impl

      ExpandedWrap disabled
        import Control.Applicative
         
        data MyCoolIO a = MCIO (IO a)
         
        instance Functor MyCoolIO where
          fmap f (MCIO xIO)  =  MCIO $ fmap f xIO
         
        instance Applicative MyCoolIO where
          pure = MCIO . pure
          (MCIO fIO) <*> (MCIO xIO)  =  MCIO $ fIO <*> xIO
         
        instance Monad MyCoolIO where
          return = pure
         
          (MCIO xIO) >>= f          =  MCIO $ xIO >>= \x -> (let (MCIO r) = f x in r)
          (MCIO xIO) >> (MCIO yIO)  =  MCIO $ yIO >>= \y -> (xIO >> return y)
         
        myPutStrLn :: String -> MyCoolIO ()
        myPutStrLn s = MCIO $ putStrLn s
         
        myMain :: MyCoolIO () -> IO ()
        myMain (MCIO io) = io



      https://ideone.com/9nbY5V

      Давай, расскажи ещё про порядок в do-выражении.

      Добавлено
      Цитата applegame @
      Значит таки можно писать императивно (по вашему определению) без мутабельных переменных?

      В нашем определении есть изменяемое состояние, а не «мутабельные переменные».

      Добавлено
      Цитата applegame @
      Последний - ИП, первые два ФП.

      Не угадал.

      Добавлено
      Цитата applegame @
      Откуда такой вывод? Почему все, если я говорил о хаскельном IO, в том числе и о монаде IO?

      Оттуда, что do-нотация работает с любой монадой, а не только монадой IO.

      Цитата applegame @
      Раз возможно IO, значит возможны функции с побочными эффектами.

      В Хаскелле нет функций с побочными эффектами.

      Цитата applegame @
      Потому что парадигма не может измениться если не меняется код Очевидно же.

      Попробуй ещё раз поразмыслить над фразой «синтаксис != семантика».

      Цитата applegame @
      Пример чего?

      Пример использования do-нотации с «чистыми» (не-IO) монадами.

      Цитата applegame @
      В чистой ФП-композиции порядок может быть любым, уже обсуждали и ты вроде согласился. Опять по кругу?

      По-моему, это ты согласился, что (foo . bar) и (bar . foo) — не одно и то же. Или ты так и не понял, что это значит?

      Цитата applegame @
      Ага, а то что эти критерии коррелируют с порядком стейтментов в do-нотации - это просто совпадение?

      Не коррелируют.
        Цитата korvin @
        Пример использования do-нотации с «чистыми» (не-IO) монадами.
        А в этих примерах нет никакой возможности проверить в каком они выполняются порядке. Можно считать что в любом, в том числе и последовательно, пофиг.
        Цитата korvin @
        Давай, расскажи ещё про порядок в do-выражении.
        А что тут рассказывать? Меняем первую и вторую строчку местами:
        ExpandedWrap disabled
          main = myMain $ do
            myPutStrLn "second"
            myPutStrLn "first"
            myPutStrLn "third"
        И, ой! Как такое могло случиться? Результат тоже поменялся:
        ExpandedWrap disabled
          third
          first
          second
        Чудеса, монада не поменялась, а порядок поменялся.
        А ведь они ваще
        Цитата korvin @
        Не коррелируют.

        В общем зря ты мучался, выводил инструкции задом наперед. :D Давай теперь программу, которая фигачит инструкции в рандомном порядке. Правда функция генерации СЧ сама будет с побочными эффектами. Придется еще сложнее мудрить код. :)
        Впрочем, подозреваю, что это таки возможно. Я даже в чистом императивном коде на D или Nim могу провернуть подобную фигню :D Правда хз, что это докажет. :)

        Добавлено
        Ладно, плевать на монады, нотации, и прочую ересь. Надоело.

        Вот:
        Цитата applegame @
        Кстати в Erlang/Elixir нет мутабельных переменных, но полно функций с побочными эффектами. Значит таки можно писать императивно (по вашему определению) без мутабельных переменных?
        Опровергайте.
        Сообщение отредактировано: applegame -
          Цитата applegame @
          И, ой! Как такое могло случиться? Результат тоже поменялся:
          Чудеса, монада не поменялась, а порядок поменялся.

          :facepalm: какой же ты, всё-таки, тупой.

          ExpandedWrap disabled
            import Control.Applicative
            import Data.Time.Clock.POSIX (getPOSIXTime)
             
            data MyCoolIO a = MCIO (IO a)
             
            instance Functor MyCoolIO where
              fmap f (MCIO xIO)  =  MCIO $ fmap f xIO
             
            instance Applicative MyCoolIO where
              pure = MCIO . pure
              (MCIO fIO) <*> (MCIO xIO)  =  MCIO $ fIO <*> xIO
             
            instance Monad MyCoolIO where
              return = pure
             
              (MCIO xIO) >>= f          =  MCIO $ xIO >>= \x -> (let (MCIO r) = f x in r)
              (MCIO xIO) >> (MCIO yIO)  =  MCIO $ do
                now <- getPOSIXTime
                if even (round now) then xIO >> yIO
                else yIO >>= \y -> (xIO >> return y)
             
            myPutStrLn :: String -> MyCoolIO ()
            myPutStrLn s = MCIO $ putStrLn s
             
            myMain :: MyCoolIO () -> IO ()
            myMain (MCIO io) = io
             
            main = myMain $ do
              myPutStrLn "first"
              myPutStrLn "second"
              myPutStrLn "third"


          Добавлено
          Цитата applegame @
          Опровергайте.

          Что опровергать? Ты даже не читаешь, что тебе пишут.

          Добавлено
          Цитата applegame @
          Правда хз, что это докажет.

          Это доказывает, что ты
          1) не читаешь, что тебе пишут
          2) не пытаешься понять, что тебе пишут
          3) не разбираешься в том, о чём пишешь
          4) продолжаешь с завидным упорством игнорировать факты
            Цитата korvin @
            какой же ты, всё-таки, тупой.
            Лентяй. second-то все время посередине. Все ещё зависит от порядка инструкций. :lol:
            Ты просто выкинь вообще результат do-нотации, и напечатай что попало. Вот это будет супер-доказательство твоей правоты: вообще ничего не будет коррелировать. :lol:

            Добавлено
            Цитата korvin @
            Это доказывает, что ты
            1) не читаешь, что тебе пишут
            2) не пытаешься понять, что тебе пишут
            3) не разбираешься в том, о чём пишешь
            4) продолжаешь с завидным упорством игнорировать факты
            Этот корвин порвался, несите другого. :D
            Сообщение отредактировано: applegame -
              applegame, ясно-понятно, ты таки достиг уровня Серёжи. Не планируешь в Израиль переехать?
                Вот сам написал:
                ExpandedWrap disabled
                  myMain x = print "VICTORY!"
                   
                  main = myMain $ do
                    print "first"
                    print "second"
                    print "third"
                Вообще никакой корреляции между порядком и вообще инструкциями и результатом. И намного проще. Учись у мастера, пока он жив. :lol:

                Добавлено
                Цитата korvin @
                applegame, ясно-понятно, ты таки достиг уровня Серёжи. Не планируешь в Израиль переехать?
                Нет, я же за Палестину. :)
                Сообщение отредактировано: applegame -
                  Цитата applegame @
                  Вообще никакой корреляции между порядком и вообще инструкциями и результатом

                  Молодец. И нахрена ты три страницы утверждал обратное? :facepalm:

                  Добавлено
                  Цитата applegame @
                  Нет, я же за Палестину.

                  Тоже неплохой вариант. Даже лучше.
                    Цитата korvin @
                    Молодец. И нахрена ты три страницы утверждал обратное?
                    Да вот, теперь сам удивляюсь. :lool:

                    Добавлено
                    Тут еще удивительное открытие.
                    Оказывается в императивных языках с побочными эффектами, от порядка инструкций тоже ничего не зависит. Как так?! :blink:

                    https://glot.io/snippets/fy5bbbksrd
                    ExpandedWrap disabled
                      import std.stdio;
                       
                      alias myMain = x => writeln("VICTORY!!!");
                       
                      void main() {
                          myMain({
                              writeln("first");
                              writeln("second");
                              writeln("third");
                          });
                      }
                      Цитата applegame @
                      Оказывается в императивных языках с побочными эффектами, от порядка инструкций тоже ничего не зависит.

                      Т.е. твоё «определение», что ИП — это порядок инструкций и ничего более, оказалось несостоятельным. Поздравляю.
                      Сообщение отредактировано: korvin -
                        Цитата korvin @
                        Т.е. твоё «определение», что ИП — это порядок инструкций и ничего более, оказалось несостоятельным. Поздравляю.
                        Хуже. Твое тоже оказалось несостоятельным. Так что и себя поздравь. И D_KEY-я не забудь. Да вообще всех поздравь, ничьё определение не оказалось состоятельным. Программирования не существует, особенно если инструкции закомментировать. :D ПА-БЕ-ДААА!
                        Сообщение отредактировано: applegame -
                          Цитата applegame @
                          Хуже. Твое тоже оказалось несостоятельным. Так что и себя поздравь. И D_KEY-я не забудь. Да вообще всех поздравь, ничьё определение не оказалось состоятельным. Программирования не существует, особенно если инструкции закомментировать. ПА-БЕ-ДААА!

                          :facepalm:
                            Я правильно понимаю, что ваш спор сводится к тому, считать ли набор локальных переменных у функции состоянием, или нет? Если это состояние, то в определении ИП по applegame состояние никуда не девается, просто оно автоматически следует из
                            последовательности инструкций, и, следовательно, не обязательно в явном виде подчёркивать его наличие. А если это не состояние, то тогда тем более нет никаких проблем с его определением.
                              Цитата applegame @
                              Так не нужно. Вот если бы можно было так:
                              ExpandedWrap disabled
                                auto z = []{ return y() + 2; };
                                auto y = []{ return x() + 1; };
                                auto x = []{ return 3; };
                              то было бы нунифигасебе.

                              Следующий наводящий вопрос. А так?
                              ExpandedWrap disabled
                                std::function<int()> x, y, z;
                                 
                                z = []{ return y() + 2; };
                                y = []{ return x() + 1; };
                                x = []{ return 3; };


                              Добавлено
                              Цитата scrambrella @
                              На С/С++ легко писать функционально.
                              Не очень легко. Но в целом запросто.

                              Добавлено
                              Цитата applegame @
                              Давай теперь программу, которая фигачит инструкции в рандомном порядке.
                              Пффф. Даже язык такой есть.

                              Добавлено
                              Нет, OpenGL. Они пытаются определить чёткие грани между двумя парадигмами, не понимая, что их нет.
                              0 пользователей читают эту тему (0 гостей и 0 скрытых пользователей)
                              0 пользователей:


                              Рейтинг@Mail.ru
                              [ Script execution time: 0,0711 ]   [ 15 queries used ]   [ Generated: 27.01.23, 00:56 GMT ]