Язык программирования karasic

    Привет, друг.


    Как известно, каждый уважаемый кодер рано или поздно пишет свой логер, парсер json и язык программирования. Поскольку первое и второе мы уже написали, то нам ничего не остаётся, как представить наши наработки по новому инновационному языку программирования karasic.



    Мир, как известно, не стоит на месте. Эволюция языков программирования не завершена. Новые языки появляются каждый год, тестируют на людях гены-фичи передают их потомкам и отмирают, кто-то раньше, кто-то позже. Большая часть нововедений в любом новом языке — это не столько новые разработки, сколько эволюция уже существующих идей и переосмысление старых методов.


    Конструируя karasic мы вдохновлялись как признанными проектами, такими как rust, python, c++, wolfram так и экспериментальными образчиками, такими как dcastf, glink, whitespace и прочими, не столь авторитетными, но от того не менее вдохновенными.


    Итак, давайте приступим к разбору фичей, которые мы вам принесли, ибо таков путь.


    Синтаксис правого присваивания


    Когда компьютеры были большими, а динозавры маленькими, отцы основатели допустили ошибку, зашив в оператор присваивания логику перемещения правого в левое, что противно интуитивно ожидаемому (если вы не японец) движению левого в правое.


    Движение правого в левое наложило отпечаток на многие технологии и в результате мы получили:


    • инструкцию ассемблера mov, в порядке аргументов которой вечно путаются студенты.
    • функции стандартной библиотеки языка си, такие как strcpy, memmove, в порядке аргументов которых студенты также путаются.

    И ладно бы мы всегда пользовались движением правого в левое, но тяга к интуитивно понятному породила:


    • утилиты командной строки cp, ln.
    • синтаксис функций стандартной библиотеки плюсов std::copy сотоварищи.

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


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


    Язык karasic вводит оператор правого присваивания:


    42 => answer
    foo(42) => answer

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


    Варианты присваивания: слева-направо и справо-налево:



    Кстати, такой синтаксис тоже валиден и может использоваться для некоторых хаков:


    42 => answer = 42

    Управление типизацией, интерпретатор против компилятора


    И поныне не умолкают холивары, какая типизация предпочтительнее, статическая, динамическая, структурная, номинативная. karasic в этом вопросе проезжает на всех санях сразу, позволяя менять типизацию по мере выполнения кода.


    <typing:dynamic> // глобальное включение динамической типизации
    
    fn foo(a,b) // динамически типизируемый код
    {
        a + b => c
        return c
    }
    
    fn bar(a:i32,b) // динамическая типизация с номинативной проверкой типа 
    {   
        a + b => c
        return c
    }
    
    [typing:static] // локальный атрибут статически типизируемой функции
    fn fubar(a:i32,b:i32) -> i32 // статически типизируемый код
    {
        a + b => c : i32
        return c
    
        // альтернативные варианты оформления возврата:
        // a + b => return
        // a + b
    }
    

    Без задней мысли вводя функционал изменяемой типизации, мы в какой-то момент обнаружили, что он открывает довольно широкий подход для оптимизаций, поскольку статическая часть поддаётся компиляции (интерпретатор выполняет её в jit режиме под нативное железо). Если программа написана полностью статически, мы можем компилироваться в исполняемый файл. (Технически мы можем это делать и с динамическим кодом, но тогда приходится зашивать интерпретатор в кишки эльфа).


    Кроме статической и динамической типизации в языке karasic также представлена типизация кинематическая. Это совершенно новый тип типизации, совсем недавно изобретённый учёным сообществом. Я не буду подробно вдаваться в тонкости этого типа типизации, ибо тема эта достойна отдельной статьи, но тонко намекну, что при кинематической типизации способ проверки типа переменной будет зависить от типов окружающих эту переменную переменных, объектного древа и мировой оси программы, поскольку полное есть композиция переносного и относительного, как гласит святая книга:



    Пробелы против табуляции


    Язык karasic предлагает красивое решение извечного вопроса, что лучше, табы или пробелы, инспирированное языком whitespace. Конечно решение, предложенное авторами языка go, когда отступы всегда обозначаются табом, а оформляемые пробелами отступы запрещены вообще, также неплохо, но мы решили что волюнтаристское назначение табов на роль символа отступника нарушает права пробельных меньшинств, что идёт вразрез с избранным современным обществом путём к терпимости и толерантности.


    В языке karasic табы и пробелы имеют разный смысл!


        a + foo(b) => c // табы
        a + foo(b) => c // пробелы

    Эти два выражения выглядят одинаково, но на деле между ними существует разница. Разница эта состоит в обработке исключений. Не секрет, что конструкции вроде


    try {
        foo();
    }
    catch (...) {}

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


    Обработка ошибок


    Продолжая тему обработки ошибок, начатую в разделе (пробелы против табуляции), язык karasic имеет довольно развитую систему работы с некорректными и исключительными ситуациями.


    Помимо классических методов, таких как обработка исключений на основе конструкции try-catch


    try {
        throw Exception(42);
    } catch ex {
        print(ex.value)
        exit(0)
    }

    , и встроенной поддержке result-союза


    fn foo() -> result(i32) 
    {
        return Exception(42)
    }

    karasic имеет некоторые неклассические способы обработки ошибок, такие как широко обсуждавшася, но так ранее и не внедренная конструкция tryso, которая, при перехвате исключения, вызывает инстанс бразузера и автоматизирует поиск ошибки на stack_overflow.


    tryso {
        throw Exception(42)
    }

    Конструкция tryso_explicit, которая делает примерно тоже самое, но вместо поиска по stack_overflow, автоматизирует создание поста с вопросом об ошибке.


    tryso_explicit {
        throw Exception(42)
    }

    Конструкция force_retry, которая повторяет выполнение кода до тех пор, пока он не выполнится корректно.


    force_retry {
        throw Exception(42)
    }


    А так же конструкция smart_try, которая выполняет код, только если он выглядит более или менее валидно.


    smart_try {
        throw casdcasd sdfsadf Exception(42) // этот код не будет выполнен.
    }

    Кроме того, есть довольно полезная конструкция shallow_throw(N), которая кидает исключение не более чем на N уровней по стеку вызовов.


    shallow_throw(n) Exception(42)

    Зачем нужна последняя авторы языка не слишком понимают, но выражают убеждение, что сообщество что-нибудь придумает.


    Ленивые интернет вычисления


    Решения многих вычислительных задач несложно нагуглить в интернете. Поэтому, умный интерпретатор karasic, встречая особенно изощрённое вычисление, не спешит выполнить его напрямую, но сперва запросит великую сеть, не решал ли кто-либо эту задачу ранее. Таким образом, вычисление факториалов больших чисел или чисел Фибоначчи на karasic имеет сложность O(1). Этот революционный метод позволяет karasic даже иногда предсказывать и выдавать в рантайме (или компилтайме для статических вариантов) исключения в случае, когда вычислительный алгоритм никогда не вернет управление, то есть karasic от случая к случаю способен решать проблему останова.



    В случае, если karasic не находит решения в сети, он проводит вычисление и выкладывает его в интернет. Финансовые возможности, а также соображения некорректности консолидации в наших руках всех знаний, что вычисляют интерпретаторы karasic по всему миру, не позволяют нам держать сервера для хранения всех этих вычислений. Поэтому karasic вместо того, чтобы использовать централизованное хранение результатов вычислений использует децентрализованный метод, выкладывая результаты на рандомные форума и борды в интернете и использует поисковую систему гугл для последующего нахождения результатов.


    Умный язык


    Известно, что время программиста очень дорого стоит. Причём немалая часть этого времени тратится не на написание кода и разработку архитектуры программного обеспечения, но на борьбу с орфографическими ошибками и синтаксическими неточностями. Современные языки вообще весьма нетолерантны к человеческому несовершенству.


    Но не karasic.



    Специально разработанный модуль искусственного интеллекта, встроенный в интерпретатор языка наткнувшись на синтаксическую или орфографическую ошибку, предсказывает, что именно программист имел ввиду и правит код прямо во время исполнения. Быстродействие при этом не страдает, особенно, если интерпретатор сконфигурирован с возможностью параллельных вычислений на gpu.


    ИИ также обучен выдавать советы по организации типовых конструкций, паттернов проектирования и при активации ментор режима может брать шефство над начинающими разработчиками.


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


    Подключение динамических библиотек и возможность импорта модулей.


    Зрелость архитектурных решений искусственных языков и архитектур программного обеспечения, а также универсальность типизации karasic позволяет выстроить универсальные интерфейсы для взаимодействия с другими языками, не требующими специальных конструкций-обёрток, используемых в lua, python и прочих языках. Бинды karasic строго прозрачны.


    Импорт пакета из python:


    import python3:numpy as np
    
    fn main() 
    {
        np.arange([42,41,40]) => arr
        np.log10(arr)
    }

    Импорт стандартной библиотеки языка си:


    import clang:string.h as cstring
    import clang:stdlib.h as cstdlib
    
    fn main() 
    {
        raw_buffer(cstdlib.malloc(40),40) => buf0
        cstring.strcpy(buf0, "HelloWorld")
    
        println(buf0) // HelloWorld
    }

    Внимательный читатель, несомненно, разглядит в этом экспериментальном импорте попытку интегрировать в язык возможности всех существующих языков и технологий, чем эта попытка несомненно и является. Нет никаких сомнений, что в будущем таки появится тот альфа и омега язык программирования, который объединит всё в себе, и, переплюнув студию Дисней, соединит в едином акте непотребства всех ситхов и джедаев разом, а не погруппно.



    Поддержка стандартных протоколов и решений


    karasic будет поставляться с набором библиотек с поддержкой большинства стандартных технологий,


    таких как RFC1149


    import rfc1149
    
    fn main() 
    {
        rfc1149.datagramm("HelloFriend") => dgramm
        rfc1149.send_bird("Петровско-разумовская аллея д.12А. метро Динамо, в ближайшую пятницу, с 17 до 20.00", dgramm)
    }

    или RFC2795


    import rfc2795
    
    fn main() 
    {
        rfc2795.monkey("Jonh") => jonh
        rfc2795.monkey("George") => george
        rfc2795.monkey("Stephen") => stephen
    
        rfc2795.monkey_group([jonh, george]) => jonh_and_george
    
        "" => sonnet    
        do  
        {
            jonh_and_george.make_sonnet(66) => sonnet
        } while(stephen.do_critic(sonnet) is false)
    
        println(sonnet)
    
        /*
    
        Tired with all these, for restful death I cry,
        As, to behold desert a beggar born,
        And needy nothing trimm'd in jollity,
        And purest faith unhappily forsworn,
        And guilded honour shamefully misplaced,
        And maiden virtue rudely strumpeted,
        And right perfection wrongfully disgraced,
        And strength by limping sway disabled,
        And art made tongue-tied by authority,
        And folly doctor-like controlling skill,
        And simple truth miscall'd simplicity,
        And captive good attending captain ill:
    
        Tired with all these, from these would I be gone,
        Save that, to die, I leave my love alone. 
    
        */
    }

    И многих других.


    Заключение


    Близится, близится тот час, когда мы с превеликим удовольствием представим миру прототип интерпретатора и документацию на язык и выложим исходники в открытый доступ. Это эпохальное событие несомненно случится и тогда мир IT уже никогда не станет прежним. Проект языка karasic не пройдёт незамеченным для широкой публики, ибо он имеет все шансы стать одним из самых важных и долгоживущих языков индустрии, прежде чем уступить место новому, более совершенному языку, переосмысляющему karasic на новый лад, в соответствии с духом времени. Хочется верить, что очень скоро мы увидим в вакансиях позиции разработчиков на языке karasic, Junior Karasic Developer, Middle Karasic Developer, а на хабре статьи на тему, как пройти собеседование на Senior Karasic Developer.


    Так пусть karasic уверенно плывёт к светлому будущему. Ура, камрады!


    Пока, друг.



    (с) provided by Karasic inc.


    Карась обыкновенный





    UPD: Английская версия текста

    Similar posts

    AdBlock has stolen the banner, but banners are not teeth — they will be back

    More
    Ads

    Comments 110

      +68

      Идеальный язык. В следующую версию добавьте, пожалуйста:


      • родственные отношения
        В обычных языках есть наследование, но оно ограничивается примитивным отношением "родитель-ребенок". Карейсик должен уметь создавать отношения вроде "богатый дядя-племянник", при завершении существования первого ресурсы передаются последнему, или "зять-тёща", увешанных взаимными промисами.
      • нетерпеливые функции, которые иногда могут и не дождаться await
      • мутирующие по ходу их написания функции (это скорее к IDE, но пусть будет)
      • блямбда-функции, облегчающие мат в документации
      • логику на основе смайликов вместо булевой
        :) = True, false => :(, ~_(°•°)_/~ = unpredictable behavior
        +3

        Усыновить чтобы в ран-тайме можно было, или в детдом сдать всех наследников

        +39
        На КДПВ плотва кстати
          +18

          Это же лошадь!

            +26
            Ну так пускай шевелится
              0

              В ростовской области её таранкой или таранью кличут.
              Так на языке и вертится: язык программирования "Таранко"…
              пысы. как раз висит на балконе вялится...

              0
              Эти два выражения выглядят одинаково

              А кто такой одинакий и за что они его выглядят?

                0
                Думаю это хабрапарсер скушал табы.
                  0

                  Да это не хабрапарсер скушал табы, а моя Т9 скушала ошибку. В оригинале там было слово "одинакого"

                +5

                Только когда дошёл до tryso вспомнил какое сегодня число

                  +6

                  Хотел написать гневно возражение на счёт дифыеренциации tab и space, но потом перевернул календарь и все понял. Гениально, что сказать!

                    +2
                    Тоже обо всём догадался на спейсах с табами.
                      +5
                      на третьем слове заголовка отпала необходимость заглядывать в календарь
                        +2

                        Ну знаете, после статей про сортировку воронками все не так просто.

                      +4
                      Неплохо было бы чтоб исходник был не просто текстом, а целым документом. Чтобы массивы можно было набивать в табличку. В комментарии пихать рисунки.
                        0
                        templeos?
                          0

                          Вот вы смеётесь, а кто-то на хабре мне неиронически доказывал, что писать комменты маркдауном и эмбеддить в них рисунки — это не только нормально, а даже и вполне удобно.

                            +4

                            Насчёт рисунков не знаю, но набирать комментарии в markdown действительно удобно.

                              0
                              кстати, какой то IDE позволял даже TeX
                                0

                                С этим-то я согласен, я в принципе стараюсь писать маркдауном где только можно. Но этот человек считал, что конкретно конструкция ![]() уместна в комментариях внутри кода.

                                  +4

                                  Конечно уместна, если из комментариев генерируется документация, как это бывает примерно во всех адекватных ЯП.

                                    0

                                    То, где кончается md, я даже html-ем пишу. Слава дока-генераторам!

                              +3

                              Пробовали Wolfram Mathematica?


                              image

                              0
                              И вас с первым апреля!
                                –15

                                Хабр — самое злое сообщество по шуткам на первое апреля. Уже какой год единственным разумным решением является просто не читать хабр пару дней. Да я брюзга.

                                  +12
                                  Кроме статической и динамической типизации в языке karasic также представлена типизация кинематическая.
                                  вы будете смеяться, но теперь я нашел имя тому поделию, которое видел 10 лет тому назад: оно умело присваивать любые структуры друг другу, присваивая только те части, которые были и в типе-источнике и в типе-получателе, (т.е. если у вас типы одинаковые — то это просто присваивание, а если это присваивание Point в Rect например — то только x и y). При этом еще умело строки в числа и обратно. В общем — все зависело от силы разработчика и энергии его желания что-то куда-то присвоить :)
                                    0

                                    А как оно в случае тех же Point и Rect поступало с недостающими в источнике полями? Оставляло имеющиеся? Если так, то это, конечно, не присваивание, но вообще-то полезная операция для всяких грязных низкоуровневых дел. Такой типа отдалённый аналог прототипного наследования, но используемый по необходимости, а не при генерации структуры (и поэтому не требующий думать о том, кто кому наследник и как это всё разрешается).


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

                                      +1
                                      да, оставляло имеющиеся.
                                      и, да, это было для UI тестирования — там действительно целая концепция на уровне архитектуры (уж не знаю — тянет это на «парадигму» или нет) чтобы можно было красиво делать композицию повторяющихся наборов действий и данных для них (и проверок с отчетами) :)
                                      0
                                      Object.assign() в js делает примерно тоже самое, только ему ещё и на типы плевать. Тупо присвоит по ключам что есть и всё.
                                        0
                                        ненене, целевые типы не перезаписывались — они нужны были для последующих операций.
                                        Например: источники данных пробовали записать свои структуры в целевую, после чего она передавалась в метод «работаем», после чего структура результата пыталась присвоиться структурам разных отчетов, и если отчет видел что он получил что-то валидное — он о себе рапортовал. Там было много и других вариаций, но подход к присваиванию структур мне запомнился надолго %)
                                      +3

                                      Не раскрыта тема "оступы vs скобочки". Карасик, как по-настоящему дружественный язык, должен принимать оба варианта.

                                        +16

                                        Причём ещё и разрешать смешивать


                                        fn main()
                                            return 0
                                        }
                                          0

                                          Тогда еще не раскрыта тема скобок вокруг условий, циклов и при вызове функций.


                                          if a > b)
                                              while (c < d:{
                                                  func( a b, c, d]
                                          end if
                                      • UFO just landed and posted this here
                                          +3
                                          a + b => c
                                          return c
                                          Не последовательно. Тогда уж: c => return
                                            +6
                                            Или сразу уже
                                            a + b => c => return


                                            Ну или для краткости return можно вообще опустить
                                            fn foo(a,b) {
                                                a + b => c =>
                                            }
                                            
                                              +4
                                              Это современный подход. Но тогда уже снова надо быть последовательным:
                                              { a + b => } fn foo(a,b)
                                                +4
                                                Как насчет:
                                                a + b => fn foo(a,b)
                                                  0

                                                  Лучше так:


                                                  (a, b) => a + b => fn foo
                                                    0
                                                    Часть
                                                    (a, b) => a + b
                                                    слишком похоже на традиционную (а следовательно, устаревшую) запись лямбда-функции.

                                                    Учитывая инновационный инвертированный порядок записи, я бы предложил:
                                                    a + b <= (a, b) => fn doo
                                                      +1

                                                      2020 год на дворе, хватит уже использовать эти уродливые составные символы и уповать на шрифты с лигатурами! Надо брать лучшее из Coq и Agda!


                                                      a + b ⇐ (a, b) ⇒ fn doo

                                                      Также ключевое слов fn может быть опущено, поскольку благодаря направлению стрелок оно становится излишним.


                                                      a + b ⇐ (a, b) ⇒ sum
                                                        0
                                                        Так как в теле функции нет локальных переменных, мы можем написать код еще лаконичнее!
                                                        a + b ⇔ sum
                                              +1
                                              Ждём систем перекомпиляции в karasic из C/C++/C# (karaCc), Java/JavaScript (karaJc), R (kaRasic), Ada (kADAsic), а также остальных, которым не хватило букв.
                                                +1

                                                Karalua, karaton, karaerl.

                                                  +1

                                                  karast забыли.

                                                    0
                                                    Еще на базе какого-нибудь языка можно написать платформы karantool и karashouse
                                                      +1
                                                      Не karast, а kaRUSTic
                                                      0

                                                      gorasic?

                                                      0
                                                      Kotliasic!
                                                      +24
                                                      К сожалению, в языке, несмотря на прогрессивное правосторонее присваивание, остались обидные стереотипы-рудименты. В частности, использование фигурных скобок в классическом порядке: {}.
                                                      Для сохранения целостности внутренней логики языка, необходимо изменить порядок следующим образом: }{. Это позволяет создать интуитивно понятное мнемоническое правило:
                                                      открывающая скобка "}" — карасик плывет вперед }<>
                                                      закрывающая скобка "{" — карасик закончил и развернулся хвостиком вперед <>{, довольно оглядывая функцию.

                                                      Еще, в статье ни слова про дебаггинг, что было бы крайне полезно, ведь язык только возник, и в карасик деве все априори будут новичками. Так что ждем дистрибутив с дебаггером jerliza и удобную графическую IDE Oparysh.
                                                        +3

                                                        ага, прямо ангуляр
                                                        Angular - Banana in a box

                                                        +1

                                                        Чёрт, я повёлся.
                                                        Было бы забавно, если бы эта штука могла компилироваться в JavaScript.

                                                          –7
                                                          Извините за вопрос, но для чего создавать колесо, когда оно уже изобретено?
                                                            +5
                                                            Чтобы потешить разум.
                                                              0

                                                              А вы имеете что-то против пятого колеса телеге?

                                                                0
                                                                Так интересно смотреть на людей, которые бросаются коментить, не прочитав статью (по крайней мере внимательно).
                                                                +1
                                                                Я извиняюсь, а можно тут карася своего выгулять?
                                                                  +3
                                                                  Spoiler header
                                                                  image
                                                                  +6

                                                                  Я считаю, что в язык нужно добавить оператор вероятностного присваивания. На дабл думает, на трипл присваивает.


                                                                  <think 0.2>
                                                                  a ?=> b
                                                                  
                                                                  # На трипл ведёт себя как а => b
                                                                  # На дабл ведёт себя как if random() <= 0.2 {a =>b}

                                                                  Более формально: значение присваивается с задаваемой пользователем вероятностью не выше 0.1 (всегда присваивает на дабл) и не ниже 0.01 (присваивает только на трипл). Вероятности ниже 0.01 не поддерживаются синтаксисом, т.к. настолько маловероятные события сложно покрыть юнит-тестами. Тем не менее, операции на квадрипл и меньшие вероятности могут быть импортированы из стандартной библиотеки. Распределение униформное, вероятность присваивания на дабл фиксированная для каждого пространства имён и задаётся оператором think <float>. Использование этого оператора несколько раз в одном пространстве имён является неопределённым поведением и кидает ворнинг.


                                                                  Так как пользователю могут понадобиться значения из других распределений, они могут быть аппроксимированы:


                                                                  # Распределение бернулли
                                                                  <think P>
                                                                  0 => b
                                                                  1 ?=>> b
                                                                  # На дабл/трипл ведёт себя как 1 =>> b (или устаревший синтаксис b+=1)
                                                                  
                                                                  # Биномиальное распределение
                                                                  
                                                                  <think P>
                                                                  N => index
                                                                  while index > 0
                                                                      {
                                                                      0 => a
                                                                      1 ?=>> a
                                                                      -1 =>> index
                                                                      }

                                                                  Распределение Пуассона аппроксимируется биномиальным при достаточно высоком N. Аппроксимация нормального распределения выполняется с использованием алгоритмов метапрограммирования. Синтаксис этой аппроксимации слишком громоздок, чтобы поместиться в данном комменте. Но базовая идея состоит в том, что заданная пользователем операция многократно рекурсивно модифицируется таким образом, чтобы создать семейство различных распределений (по дефолту тысячу, но количество может быть определено аргументом компилятора). Затем из каждого распределения берётся по одному значению в том же диапазоне, что и исходная операция. Согласно Центральной предельной теореме, их среднее арифметическое распределено нормально.

                                                                    +1

                                                                    Это называется анонимные функции алкоголиков или ай-да-функции!

                                                                      0

                                                                      А степень примерном и задаётся количеством ~
                                                                      a ~~~~=> b

                                                                        0

                                                                        Оператор примерного присвоения
                                                                        a ~=> b
                                                                        А степень примерном и задаётся количеством ~
                                                                        a ~~~~=> b

                                                                      0
                                                                      Whenever на стероидах?
                                                                      0
                                                                      Лучше бы в Паскалевском стиле было бы сделать
                                                                      := — левое присваивание
                                                                      =: — правое присваивание
                                                                      :-)
                                                                      Вообще хорошая первоапрельская статья получилась.
                                                                        0
                                                                        И реализовать KARASIC на Форте или Лисп-е ;)
                                                                        С Первым апреля! Улыбайтесь чаще!
                                                                          +1
                                                                          Шутка шутками, но идеи управления типизацией, возможность выбора между статической или динамический компиляцией, а также интерпретацией выглядят круто. Жду репозиторий
                                                                            +1
                                                                            В Cython есть что-то похожее.
                                                                            Если везде указываем тип переменных, функций, то это позволяет компилятору оптимизировать код. Если нет — то код выполняется в рантайме Python.
                                                                              +1
                                                                              Ну type hinting тоже где-то рядом стоял (python, PHP). А оптимизации прикрутили даже к duck-typed языку JS через набор правил asm.js
                                                                              +5
                                                                              Выпивает компания металлистов:
                                                                              — Кузнец! Кузнец куёт МЕТАЛЛ — выпьем за кузнеца, выпьем за металл! Металл!!!
                                                                              — Сталевар! Сталевар выплавляет МЕТАЛЛ — выпьем за сталевара, выпьем за металл! Металл!!!
                                                                              — Карасик!
                                                                              — ??!!!
                                                                              — Карасик… потому что он икру МЕТАЛ! Метал!!!


                                                                              А вообще tryso — это ж гениально, интересно может на гитхабе уже есть Java agent который добавляет ссылку на stackoverflow ко всем брошенным exception? Если нет — так надо ж сделать, тысяча звезд гарантирована, хороший пункт в резюме )
                                                                              0
                                                                              Ждем, когда язык станет настолько востребован, что даже разработчики Linux позаимствуют парадигму кинематической линковки библиотек)
                                                                                0
                                                                                Я думаю, что для него нужен отдельный редактор, похожий на аквариум, чтобы буквы плавали, как икринки.
                                                                                  0
                                                                                  ЯП выглядит достаточно интересно. Я бы даже сказал революционно. Но вот отступы — это беда. Отступы — ненужный рудимент, оставшийся от классических ЯП из середины прошлого столетия. По моему скромному мнению, от них надо отказаться вообще. Вместо долгих рассуждений по код-стайлу табуляция/пробелы можно всегда использовать переносы строк.

                                                                                  fn foo(a,b)
                                                                                  {
                                                                                  
                                                                                  a + b => c
                                                                                  return c
                                                                                  
                                                                                  }

                                                                                  В случаях, когда выразительности переносов не хватает, следует применять эвристику.
                                                                                  
                                                                                  if a > b
                                                                                  
                                                                                  b = a
                                                                                  
                                                                                  a = b
                                                                                  
                                                                                  

                                                                                  Чем больше переносов строк, тем больше надо полагаться на анализатор ЯП, чем на сам код. Таким образом будет решена давняя проблема «выполняется не то, что хотел программист, а то, что он написал».
                                                                                  Однако, сразу можно найти проблему, что оценивать уровень программистов будут по количеству перенов строк в их коде, т.к. чем больше, тем лучше программист дает контекст для анализатора, что позволяет использовать более глубокий анализ, следовательно более оптимизированный и красивый код.
                                                                                  Также будет решены трудности тех безумцев, что поворачивают монитор на 90 градусов.
                                                                                    0
                                                                                    Лучше-бы запретили прямой порядок байтов…
                                                                                      0
                                                                                      тот случай когда чтение каментов доставляет не хуже чем статья.
                                                                                      Предлагаю ввести панику (мне ее после GoLang не хватает) и поддерживаю логику на смайлах и вероятностное присваивание.
                                                                                      Соответственно название проапгрейдить до CarassiusAuratis.
                                                                                        0
                                                                                        Этому языку родные рантайм-библиотеки не нужны от слова совсем. Он может использовать рантайм любого языка, который по душе разработчику.
                                                                                          +5
                                                                                          А назван он в честь Маргарет Корасик, которая вместе с Альфредом Ахо придумали алгоритм поиска подстроки?
                                                                                            0
                                                                                            На фото не карась.
                                                                                              0

                                                                                              Ну вот — даже в КДПВ обманули.

                                                                                                0
                                                                                                Прям оглаф какой-то.
                                                                                                  0

                                                                                                  Не Оглаф. Первая половина типичного Оглафа где?

                                                                                              0
                                                                                              Перловые модули поддерживает?
                                                                                                0
                                                                                                А то! Без этого не взлетит
                                                                                                0
                                                                                                  +3
                                                                                                  а ещё можно feature request?
                                                                                                  порой бывает, что нужно вернуть значение, а потом его же вернуть из вызывающей функци а та, в свою очередь,… ну вы поняли.
                                                                                                  так вот все эти долгие ретурны чтоб заменить на
                                                                                                  value ===> return, чтоб длина стрелочки указывала, как далеко нужно возвращать значение.
                                                                                                    +1
                                                                                                    И в придачу особый оператор "возврат из восьмерки" (длина оператора не имеет значения), выкидывающий из последовательности вызовов методов (включая рекурсию) без паники и нарушения целостности исполнения любого алгоритма:
                                                                                                    Извините
                                                                                                    8=>
                                                                                                      0
                                                                                                      Тогда вам в брейнфак, там всё такоэ… длииииииинное.
                                                                                                      0
                                                                                                      Новый язык и без вычислений на основе квантовой неопределенности — муветон прямо таки.
                                                                                                        –1
                                                                                                        Выбирали название всем Двачем
                                                                                                          +1
                                                                                                          Хотелось бы еще добавить фичареквест про эвристическое вычисление:

                                                                                                          /**
                                                                                                            * функция возвращает такой кортеж (a, b),
                                                                                                            * который удовлетворяет условию a + b = c и 
                                                                                                            * не приводит к фатальной ошибке исполнения
                                                                                                           **/
                                                                                                          fn foo(c)
                                                                                                          {
                                                                                                              c => a + b
                                                                                                              return (a, b)
                                                                                                          } 
                                                                                                            +2

                                                                                                            И так не будет ошибки — вы же пробелы использовали, а не табы.

                                                                                                          • UFO just landed and posted this here
                                                                                                              0
                                                                                                              В языке karasic табы и пробелы имеют разный смысл!

                                                                                                              a + foo(b) => c // табы
                                                                                                              a + foo(b) => c // пробелы

                                                                                                              Но ведь пробелы и так и там! :)

                                                                                                                +6

                                                                                                                Почему никто не называет язык программирования "Помидор"?


                                                                                                                Это же круто. Открываешь вакансии, а там требуется сеньор помидор.
                                                                                                                Открываешь стэковерфлоу, пишешь проблему, а в ответ прилетает кусок помидора.

                                                                                                                  0

                                                                                                                  А нет ли версии этого шедевра на английском? Очень хочется коллег порадовать.


                                                                                                                  Ну и спасибище, конечно!

                                                                                                                    0
                                                                                                                    Боюсь я не настолько хорошо владею английским, чтобы сделать достойный перевод.
                                                                                                                      0

                                                                                                                      Обещать не могу, но если выдастся часок, я сделаю тогда.

                                                                                                                        0
                                                                                                                        Если вдруг, обязательно дайте почитать!
                                                                                                                          0

                                                                                                                          Вы меня за кого принимаете? :)


                                                                                                                          Я не только почитать дам, я его вам высылаю для правки — и — если хотите — публикации где угодно. Я его всерьез не вычитывал, возможны описки и / или ляпы. Не обессудьте.


                                                                                                                          https://gist.github.com/am-kantox/4cb513a300e66762e30563898b5bc781


                                                                                                                          Исходник полностью годен для публикации в режиме маркдауна на хабре; опубликуйте в англоязычной версии, если не сложно. Ссылаться на меня не обязательно.

                                                                                                                            0
                                                                                                                            Это прекрасно.
                                                                                                                            Я таки внесу пару мелких доработок и сразу же опубликую :).

                                                                                                                            Правильное присваивание мне особенно понравилось.
                                                                                                                            I need an accounting system

                                                                                                                            P.S. Жаль, что слово assingment в английком языке, как мне кажется, не несёт в себе того же подсмысла, что и в русском. Насколько я знаю, оно обычно в значении «воровать не употребляется». И двое из ларца оказываются не особенно в тему.
                                                                                                                              0

                                                                                                                              Да, «assignment» так не употребляется, и я даже покрутил туда-сюда «ad-hog», но не смог его вставить так, чтобы не оттянуть на надуманную игру слов смысл.


                                                                                                                              Ну отлично, рад что пришлось впору.

                                                                                                                  0
                                                                                                                  Выглядит будто кто-то решил исполнить мечту Пола Грэма про «достаточно умный компилятор».
                                                                                                                  Прямо жаль что шутка, мне аж интересно стало посмотреть на результат)
                                                                                                                    –1
                                                                                                                    Мы вводим правое присваивание оператором БОЛЬШЕ ИЛИ РАВНО! Воу, никакой путаницы, интуитивно понятное… Кому? Мне моск сломала запись «42 больше или равно ответ» — это выражение имеет какие-то последствия? А потом очень туго вкурил, что это не сравнение, а типа присваивание. Вообще непонятно. Шутка какая-то мутная получилась в итоге. Не надо так. Надо шутить, а не загаживать моск.
                                                                                                                      +1

                                                                                                                      Сравнение всегда обозначалось как >= — "больше или равно", а не символами =>. PHP, например, спокойно использует последние в определении массивов.

                                                                                                                        +2
                                                                                                                        Вообще, в свете присутствия как правого, так и левого присваивания я бы предложил несколько assignment-операторов:
                                                                                                                        • a => b значение переменной a присваивается переменной b
                                                                                                                        • a >= b значение переменной a переносится в переменную b, а переменная a становится деинициализированной
                                                                                                                        • a <= b значение переменной b присваивается переменной a
                                                                                                                        • a =< b значение переменной b переносится в переменную a, а переменная b становится деинициализированной
                                                                                                                        • a := b ссылка на переменную a присваивается переменной b
                                                                                                                        • a =: b ссылка на переменную ba присваивается переменной a

                                                                                                                        Кроме того, разрешаются сбродные сводные операторы >=> <=< =>> <<= :=> :>= <=: =<: =>: >=:, выполняющие все эти действия разом.
                                                                                                                        Как же тогда сравнивать на «больше или равно» и «меньше или равно»?
                                                                                                                        Ну, либо через (a == b) & (a > b), либо через объединение операторов: a ==|> b или a ==+> b
                                                                                                                      0
                                                                                                                      Хорошо что хоть не Каракас!
                                                                                                                        –1

                                                                                                                        Надо обязательно слоган
                                                                                                                        Don"t Panic

                                                                                                                        Only users with full accounts can post comments. Log in, please.