LINUX.ORG.RU

Где можно обращаться к предпоследнему элементу списка как List(END-1) ?

 , ,


0

2

Получить предпоследний элемент списка:

lindex {1 2 3 4} end-1

Питон:

some_list[-2]
В Перле подобное же.

Если сравниваем, то видим, что python и Перл - это кака, а tcl - конфетка. Проблемы питона: а вдруг я не имел в виду индекс с конца, а просто ошибся и неправильно вычислил индекс? А вдруг в списке всего один элемент? Правда, и tcl не выдаст ошибки, а выдаст пустую строку, но зато хотя бы есть способ _ясно_ сказать, что я имею в виду именно элемент энный с конца. Это вроде мелочь, но в tcl таких мелочей много и они хорошо складываются.

Соответственно, вопрос такой: откуда такие красивые мелочи в tcl, и где ещё подобное есть?

И вот предварительные итоги опроса

D: - знак доллара $

bar[0 .. $]

Matlab, Julia - так же как в tcl

xs[end-1]

red - особый сахар для итераторов, хотя и не совсем то же:

 first back back tail a

С++ - итераторы приближаются к желаемому, хотя не совсем то

std::prev(std::prev(std::end(some_container)))
Также есть advance, к-рый позволяет не считать на пальцах. Однако для извлечения подсписка придётся обратиться к списку дважды, или запомнить итератор в переменной. А ещё вот так: std::end(v)[-2];

Rust - примерно то же, что С++, Вот велосипед для извлечения середины списка. Итератор от конца

v.iter().rev()

Haskell - можно сделать

data Index = Begin Int | End Int
По сути это решение можно реализовать в любом ООП языке, если вместо индекса использовать объект, и ввести объект «индекс от конца» - потомок индекса. Тут возникают вопросы про то, что это не интегрировано в стандартную библиотеку. Насчёт интеграции в такую библиотеку некие слова были сказаны, но уверенного «да запросто» я не припомню.

Ada, VHDL - сахар для получения индекса последнего элемента, т.е. не то, что надо

A'Last

Антиприз достаётся Перлу и Питону, у которых для получения элемента от конца используется отрицательный индекс:

а[-2]
Этот факт не даёт выявить в рантайме такую ошибку, как ошибочно вычисленный отрицательный индекс. Антиприз мог бы получить и сам tcl, поскольку у него доступ к индексу за пределы массива возвращает пустоту. Однако в tcl этот вопрос ортогонален к вопросу получения предпоследнего элемента, а в Питоне и Перле - нет.

★★★★★

Последнее исправление: den73 (всего исправлений: 6)

Ответ на: комментарий от Virtuos86

Здесь $ обозначает конец по мотиву регэкспов?

Товарищ молчит, вот я нашёл в доке по D, правда у них похоже, верхняя граница не включается в Range:

int[4] foo;
int[]  bar = foo;
int*   p = &foo[0];

// These expressions are equivalent:
bar[]
bar[0 .. 4]
bar[0 .. $]
bar[0 .. bar.length]

den73 ★★★★★
() автор топика
Ответ на: комментарий от den73

Мысль я понял. В принципе, в случае динамического импорта типа (синтаксис python)

__import__(just_created_path)
эти модули можно «компилировать» и там раскрывать этот макрос end. Но проблема получения индекса из файла остаётся.

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

very_long_long_long_name[len(very_long_long_long_name)-1]
питонисты скажут «Beautiful is better than ugly».

Crocodoom ★★★★★
()
Ответ на: комментарий от AndreyKl

Собственно, ждём ответа Tcl-истов.

да ладно, это фантастика, их не бывает поди.

Был у нас на работе один, написал числодробилку. Внутри C++ (вычислительное ядро), а вот вся скриптота на тикле.

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

Crocodoom ★★★★★
()
Ответ на: комментарий от Virtuos86

Здесь $ обозначает конец по мотиву регэкспов?

Откуда мне знать? Я его не разрабатывал.

Esper
()
Ответ на: комментарий от I-Love-Microsoft

predp

очень плохое название
pred — сокращение от predicate
и окончание p — тоже означает предикат
predp — функция, которая проверяет является ли её аргумент предикатом.

Как ты вообще придумал такое название?

Bad_ptr ★★★★★
()
Ответ на: комментарий от AndreyKl

lindex {1 2 3 4} index_from_file(«file»)

а что вы хотели сказать этой строкой ? «прочесть индекс из файла и по нему вытащить элемент из списка» ??

lindex { 1 2 3 4 5 } [ read_one_integer «file» ]

или что-то другое..tcl (как и lisp) тяготеют к тому чтобы программист делал «свой язык»/DSL для решения некоторого круга своих задач. Что захотел, то и получил.

MKuznetsov ★★★★★
()
Ответ на: комментарий от MKuznetsov

«прочесть индекс из файла и по нему вытащить элемент из списка» ??

Да

[code]lindex { 1 2 3 4 5 } [ read_one_integer «file» ][/code]

Внимание вопрос: это будет работать, если в файле записана строка «end-1»?

Crocodoom ★★★★★
()
Ответ на: комментарий от Crocodoom

это будет работать, если в файле записана строка «end-1»?

если read_one_integer вернёт строку «end-1», то да, работать будет

MKuznetsov ★★★★★
()
Ответ на: комментарий от Crocodoom

Но проблема получения индекса из файла остаётся.

Это будет как-то так:

end-[GetIndexFromFile]

Если бы мы писали сверх-умный компилятор tcl-я, можно было бы увидеть, что строка не является константой и рассахарить это (перевожу на Си-образный язык) как

length(this_array)-GetIndexFromFile()

Но на рассахаренную запись

Именно поэтому end-1 (в данном случае просто end) и рулит.

den73 ★★★★★
() автор топика
Ответ на: комментарий от Crocodoom

решили тикль выкинуть и написать всё заново на питоне.

Ну и зря. В тикле нативный гуй, а в питоне гуй - это либо тот же Tk, либо Qt. В первом случае вы не сумели толком выкинуть тикль :) В любом случае, это проблема не языка, а его популярности.

den73 ★★★★★
() автор топика
Последнее исправление: den73 (всего исправлений: 1)
Ответ на: комментарий от Virtuos86

Я понял, что ты только высказал предположение. По ссылке написано. Да, это сахар, почти идентичный тиклевскому end.

den73 ★★★★★
() автор топика
Ответ на: комментарий от MKuznetsov

если read_one_integer вернёт строку «end-1», то да, работать будет

Значит, вся эта кухня работает в рантайме, что я и хотел выяснить, спасибо.

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

Crocodoom ★★★★★
()
Ответ на: комментарий от AntonyRF
impl<'a, T> Send for std::vec::Drain<'a, T> 
impl<'a, T: ?Sized> !Send for RwLockReadGuard<'a, T>

Вообще это довольно жестковато читается, если честно. Мне такой код на Расте пока не доводилось писать, обхожусь элементарщиной. Оффтоп, но меня убивает, что в Расте жутко неудобно иметь глобальные мутабельные объекты. А иногда надо.

Virtuos86 ★★★★★
()
Ответ на: комментарий от system-root

list.pop()

Если это односвязный список, то pop выкидывает первый элемент.
А в python это не список, а массив.

Bad_ptr ★★★★★
()
Ответ на: комментарий от Virtuos86

Оффтоп, но меня убивает, что в Расте жутко неудобно иметь глобальные мутабельные объекты. А иногда надо.

Вы про Box<_> ?

AntonyRF ★★★★
()

Haskell

> (last . init) [1,2,3,4,5]

4
anonymous
()

Кстати да, на хаскелле это можно спокойно реализовать. Причём именно в том синтаксисе, как в Tcl.

Демонстрирую

data End = End | Succ End | Pred End deriving Show
data Index = IndexI Int | IndexE End deriving Show

instance Num Index where
{--
Тут аккуратно определяем арифметику, вырезал для краткости
--}                                          
infixr 2 !    
(!) :: [a] -> Index -> a           
list ! (IndexI i) = list !! i         
list ! (IndexE (Succ e)) = undefined  
list ! (IndexE (Pred e)) = init list ! (IndexE e)
list ! (IndexE End) = last list 
                                                                                
end = IndexE End   

Как работает

$ ghci indexing.hs
GHCi, version 7.10.3: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Main             ( indexing.hs, interpreted )
Ok, modules loaded: Main.
λ> let x = [1 .. 5]
λ> let y = [1 .. 7]
λ> x ! 1
2
λ> y ! 1
2
λ> x ! end
5
λ> y ! end
7
λ> x ! end-2
3
λ> y ! end-3
4
λ> x ! end+1
*** Exception: Prelude.undefined

Crocodoom ★★★★★
()
Ответ на: комментарий от den73

индексы end-$e поддерживаются системно при всех операциях со списком

В С++ тоже.

BruteForce ★★★
()
Ответ на: комментарий от AntonyRF

Нет. Допустим, у меня есть main.rs и модуль foo.rs.
В модуле foo есть структура Bar.
Я хочу иметь возможность изменять структуру Bar и в main.rs, и в модуле foo.
Напрашивается поместить Bar в глобальной области видимости.
Делаем это так: static mut BAR: Bar = Bar {...};

Теперь доступ к полям BAR нужно оборачивать в блок unsafe. Плюс, я натыкался еще на какие-то проблемы, уже забыл конкретно. Вот сегодня выяснил, что Bar нельзя инстанциировать callable объектом, т.е. создавать структуру с помощью, например, Bar::new() не получится.

Может, конечно, я хочу чего-то странного.

Virtuos86 ★★★★★
()
Ответ на: комментарий от Crocodoom

Тут аккуратно определяем арифметику

А скорость работы при таком определении арифметики? Или она умно приводится к обычным числам? Ну и здесь ты по сути начал заново создавать библиотеку работы со списками. Конечно, в этом можно преуспеть, но это большая работа.

Сейчас я пытаюсь понять, стоит ли встроить в Яр такую вещь на уровне системы. До меня наконец дошло, что так и надо делать, и тут вижу твою запись:

data Index = IndexI Int | IndexE End

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

В tcl скорее всего это было бы возможно добавить (за неизвестно какую цену по производительности), в С++ вряд ли возможно, про Хаскель и Раст не знаю. Язык должен быть метациркулярным или с удобной открытой архитектурой, чтобы делать такие трюки. tcl в большой степени таковым является, лисп в небольшой, плюсы - думаю, что почти не в какой, хотя не знаю за clang.

den73 ★★★★★
() автор топика
Ответ на: комментарий от Crocodoom

Версия 2

Так попроще и понятнее будет

data Index = Begin Int | End Int

instance Num Index where
{--
Тут аккуратно определяем арифметику, вырезал для краткости
--}                                                
           
infixr 2 !                     
(!) :: [a] -> Index -> a          
list ! (Begin i) = list !! i            
list ! (End e) = list !! (length list + e - 1) 
end = End 0

λ> let x = [1 .. 5]
λ> let y = [1 .. 7]
λ> x ! 0
1
λ> x ! end
5
λ> y ! end-1
6
λ> y ! end+1
*** Exception: Prelude.!!: index too large
Crocodoom ★★★★★
()
Ответ на: комментарий от BruteForce

Разберёмся с плюсами:

std::next(std::rbegin(some_container))
Это же наверное итератор, а нужно значение, т.е. нужно ещё какую-то операцию «разыменования итератора», не?

Ну, наверное, ты прав всё же, хотя выглядит это довольно неуклюже, но с семантической точки зрения одно и то же. Другое дело, если тебе нужно получить подсписок от 7-го элта с конца до 3-го эл-та с конца, вряд ли будет легко обойтись одним обращением к контейнеру. Ну и вообще приращение итераторов - это не совсем то. Не факт, что твои std::prev(std::prev(std::end)) будут считаться с той же скоростью, что и простое вычитание двойки из длины. Например, итератор может проверять, что находится не в начале списка, на каждом приращении, и end-100 получится весьма дорогим. Хотя на стороне этого решения общность.

den73 ★★★★★
() автор топика
Ответ на: комментарий от den73

Посмотри ещё вторую версию моего кода.

А скорость работы при таком определении арифметики?

0 в рантайме. По-крайней мере, для выражений типа list ! end-k, даже если на этапе компиляции значение k неизвестно.

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

Yep!

стоит ли встроить в Яр такую вещь на уровне системы

Встраивай, будет киллер-фича. А что за Яр?

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

Вовсе нет, можно делать уже на уровне юзера, и при том нативно. Для этого нужна либо сильная система типов (Haskell), либо синтаксические макросы (Rust?), либо ещё какие-то фичи.

Crocodoom ★★★★★
()
Ответ на: комментарий от den73

какую-то операцию разыменования

Держи, мне не жалко:

*

Если у тебя в списке какй-то объект и ты хочешь его подергать, то держи эту:

->

BruteForce ★★★
()
Последнее исправление: BruteForce (всего исправлений: 1)
Ответ на: комментарий от Crocodoom

Насчёт киллерности этой фичи я сомневаюсь, половина народа даже не поняла, о чём речь. Но допустим. Яр - это язык трудной судьбы, к-рый я два года назад собирался написать за два месяца, и теперь он уже готов почти наполовину. Посмотри теги с темой Яр. Пример факториала По сути это инкрементный транслятор в лисп с больше склонностью к статической типизации за счёт сахара над уже существующими в лиспе декларациями типов. И из оставшихся киллер-фич осталась только горячая замена кода (правда и про неё большинство считает, что это зло). Остальные либо реализованы в C# или Scale, либо я про них даже не знаю (из Хаскеля).

Из киллер фич для России - то, что он русскоязычный. Кто не в курсе, наиболее востребованные программисты в России - для русскоязычного языка 1С (по числу вакансий). Так что в сумме около двух «киллер» фич.

Вовсе нет, можно делать уже на уровне юзера, и при том нативно.

Ну вот в CL есть макросы вряд ли слабее, чем в Расте, но я смотрю на это и понимаю, что сделать это для CL так, чтобы оно проросло в недра языка, малореально. Написать свою библиотеку - это легко, сделать, чтобы она оптимизировала случай отсутствия слова end - тоже нетрудно. А вот прорастить в ядро - нет.

den73 ★★★★★
() автор топика
Ответ на: комментарий от den73

с той же скоростью

Будут считаться с максимально возможной.

подсписок от 7-го элта с конца до 3

Если от 3(включ.) до 7(не включ):

new_container{std::begin(v) + 2, std::end(v) - 7};

Тоже самое, но как ты написал (с конца в начало, обратный порядок элементов):

    new_container{std::rbegin(v) + 7, std::rend(v) - 2};

Да, «обратиться» к контейнеру придется два раза, но это:

  • Еще более наглядно над каким контейнером ты работаешь
  • Можно начало взять у одного контейнера, а конце у другого. Может ли так тикль?
BruteForce ★★★
()
Ответ на: комментарий от BruteForce

Ну насчёт «с максимально возможной» не верю, но спорить не стану ввиду отсутствия ресуров на такой спор. В остальном в принципе плюсы лучше, чем питон но всё же до тикля, D и теперь вот может быть Хаскеля не дотягивает. Хотя понятно, что можно и по-другому как-нибудь подойти. В целом с плюсами ясно, спасибо.

Остаётся вопрос, как тиклеобразный end-1 интегрировать в язык с бейсик-подобным синтаксисом, чтобы не было слишко страшно на вид.

den73 ★★★★★
() автор топика
Ответ на: комментарий от BruteForce

Можем написать бенчмарки.

Да не суть важно.

den73 ★★★★★
() автор топика
Ответ на: комментарий от BruteForce

С этим языком никто не сравнится.

Офтопик, но всё же спрошу: что там такого хорошего и почему он тогда не взлетел?

den73 ★★★★★
() автор топика
Ответ на: комментарий от den73

киллер-фича языка D

CTFE функции — через библиотеку доступен почти весь компилятор.

прозрачная линковка с Си, COM и dll в Windows, std.posix.

с с++ можно линковаться через Callypso, есть транслятор из Java в D через source transformation (например DWT построена из SWT полуавтоматически)

батарейки через dub.

рефлексия, typeinfo, метаданные. std.meta очень крутая вещь.

например, парсер JSON времени компиляции очень быстрый. подобный же есть XML парсер.

интересный пример кода: pegged библиотека — PEG парсер времени компиляции, на CTFE функциях.

например, Legioner (будучи студентом Столярова с InteLib) писал на D v1 схему (похоже, Столяров многим студентам такое задание давал — по аналогии с InteLib/C++ взять нечто_своё/другой_язык)

но он её недоделал, сейчас до D v2 там совсем немного допилить надо. а так был бы вполне себе годный минималистичный недолисп времени компиляции, на CTFE функциях.

почему не взлетел D (и не взлетел ли) — хз. по-моему, развитие определённое там есть.

наконец, на D написано минималистичное Literate Programming средство: literate. встраивается в micro, работает из коробки в полпинка.

в языке D нет столько легаси boilerplate как в С++ --- и это прекрасно же.

а динозавры С++ нудят: «не взлетел». лол.

anonymous
()
Ответ на: киллер-фича языка D от anonymous

cast den73pegged: вот эти примеры грамматик во время компиляции, CTFE функциями раскручиваются в работающий код на D.

например, Oberon-2

если сделать term rewriting, и какие-то оптимизации — получится быстрый парсер времени компиляции, на CTFE функциях.

примерно как boost::spirit в C++, только с более человекопонятным синтаксисом.

при этом естьмодули грамматик, композиция модулей.

обучалка

в общем, смотри презентацию с конференции DConf 2017 года

anonymous
()
Ответ на: киллер-фича языка D от anonymous

писал на D v1 схему (похоже, Столяров многим студентам такое задание давал — по аналогии с InteLib/C++ взять нечто_своё/другой_язык)
но он её недоделал, сейчас до D v2 там совсем немного допилить надо

Исходники-то есть?

Bad_ptr ★★★★★
()
Ответ на: комментарий от anonymous

вот этот пример, 49-я строка:

  enum answer = value(parseTree);

enum означает константу времени компиляции

значит, функция выполняется во время компиляции.

значит, парсинг и построение AST выполняется во время компиляции. для этого активно используются typeinfo, рефлексия, std.meta, std.algorithm

в конечном коде остаётся готовая константа типа AST-дерево.

eval такого дерева тоже можно сделать функциями времени компиляции, если получится.

в итоге эти макросы времени компиляции раскроются в одну константу — значение eval дерева.

anonymous
()
Ответ на: комментарий от Bad_ptr

scheme4d/tests/arithmetic1.d:

import scheme.common;

void main()
{
    mixin(parse(r"
(define a (+ 2 3))
(define b (* a (+ a 3)))
(define c (- 1 2 3))
"));
    assert(a.toInt() == 5);
    assert(b.toInt() == 40);
    assert(c.toInt() == -4);

    mixin(parse("(+)"));
    assert(result.toInt() == 0);
    mixin(parse("(- 1)"));
    assert(result.toInt() == -1);
    mixin(parse("(- 1 2)"));
    assert(result.toInt() == -1);
    mixin(parse("(*)"));
    assert(result.toInt() == 1);
    mixin(parse("(> 1 0)"));
    assert(result.expression() is symbol("#t"));
    mixin(parse("(> 0 1)"));
    assert(result.expression() is symbol("#f"));
}

tests/t3.d:

import scheme.common;
import std.stdio;

void main()
{
    mixin(parse(r"
(define a 1)
(define b 2)
(define c (lambda (x) (lambda (y) (+ x y))))
(define l (c a))
(define r (l b))
"));

    assert(a == 1);
    assert(b == 2);
    assert(r == 3);

    auto e1 = c(7);
    
    assert(e1(8) == 15);

    mixin(parse(r"
(define fact (lambda (n) (if (> n 0) (* n (fact (- n 1))) 1)))
"));
    assert(fact(5).toInt() == 120);
}

anonymous
()
Ответ на: комментарий от Virtuos86

в Расте жутко неудобно иметь глобальные мутабельные объекты

Так это не безопасно. Вот и боль.

А иногда надо.

Быдлокод же.

RazrFalcon ★★★★★
()
Ответ на: комментарий от anonymous

tests/parser.d:

import scheme.parser;

void main()
{
    static assert(parse(r"
a
") ==
		  `static if(!is(typeof(result):ExpressionWrapper)){ExpressionWrapper result;}`
		  `result=new ExpressionWrapper(symbol("a").compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment));`
	);
		  
    static assert(parse(r"
(a)
") ==
		  `static if(!is(typeof(result):ExpressionWrapper)){ExpressionWrapper result;}`
		  `result=new ExpressionWrapper(list(symbol("a")).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment));`
	);

    static assert(parse(r"
(define f (lambda (x y) (+ x y +1)))
") ==
		  `static if(!is(typeof(f):VariableWrapper)){VariableWrapper f=new VariableWrapper(symbol("f"));}`
		  `static if(!is(typeof(result):ExpressionWrapper)){ExpressionWrapper result;}`
		  `result=new ExpressionWrapper(`
		  `list(symbol("define"),symbol("f")`
		  `,list(symbol("lambda"),list(symbol("x"),symbol("y")),list(symbol("+"),symbol("x"),symbol("y"),number(+1))))`
		  `.compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment));`
		  );

    static assert(parse(r"
(define a 1)
(define b 2)
(define c 3)
") ==
		  `static if(!is(typeof(a):VariableWrapper)){VariableWrapper a=new VariableWrapper(symbol("a"));}`
		  `static if(!is(typeof(b):VariableWrapper)){VariableWrapper b=new VariableWrapper(symbol("b"));}`
		  `static if(!is(typeof(c):VariableWrapper)){VariableWrapper c=new VariableWrapper(symbol("c"));}`
		  `static if(!is(typeof(result):ExpressionWrapper)){ExpressionWrapper result;}`
		  `list(symbol("define"),symbol("a"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("b"),number(2)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `result=new ExpressionWrapper(`
		  `list(symbol("define"),symbol("c"),number(3)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment)`
		  `);`
	);
    

anonymous
()
Ответ на: комментарий от anonymous
    static assert(parse(r"
(define ! 1)
(define $ 1)
(define % 1)
(define & 1)
(define * 1)
(define + 1)
(define - 1)
(define / 1)
(define : 1)
(define < 1)
(define = 1)
(define > 1)
(define ? 1)
(define ^ 1)
(define _ 1)
(define a. 1)
(define ~ 1)
(define ... 1)
"),
		  `static if(!is(typeof(S1):VariableWrapper)){VariableWrapper S1=new VariableWrapper(symbol("!"));}`
		  `static if(!is(typeof(S4):VariableWrapper)){VariableWrapper S4=new VariableWrapper(symbol("$"));}`
		  `static if(!is(typeof(S5):VariableWrapper)){VariableWrapper S5=new VariableWrapper(symbol("%"));}`
		  `static if(!is(typeof(S7):VariableWrapper)){VariableWrapper S7=new VariableWrapper(symbol("&"));}`
		  `static if(!is(typeof(S8):VariableWrapper)){VariableWrapper S8=new VariableWrapper(symbol("*"));}`
		  `static if(!is(typeof(SP):VariableWrapper)){VariableWrapper SP=new VariableWrapper(symbol("+"));}`
		  `static if(!is(typeof(SM):VariableWrapper)){VariableWrapper SM=new VariableWrapper(symbol("-"));}`
		  `static if(!is(typeof(SD):VariableWrapper)){VariableWrapper SD=new VariableWrapper(symbol("/"));}`
		  `static if(!is(typeof(ST:VariableWrapper)){VariableWrapper ST=new VariableWrapper(symbol("):"));}`
		  `static if(!is(typeof(SL):VariableWrapper)){VariableWrapper SL=new VariableWrapper(symbol("<"));}`
		  `static if(!is(typeof(SE):VariableWrapper)){VariableWrapper SE=new VariableWrapper(symbol("="));}`
		  `static if(!is(typeof(SG):VariableWrapper)){VariableWrapper SG=new VariableWrapper(symbol(">"));}`
		  `static if(!is(typeof(SQ):VariableWrapper)){VariableWrapper SQ=new VariableWrapper(symbol("?"));}`
		  `static if(!is(typeof(S6):VariableWrapper)){VariableWrapper S6=new VariableWrapper(symbol("^"));}`
		  `static if(!is(typeof(_):VariableWrapper)){VariableWrapper _=new VariableWrapper(symbol("_"));}`
		  `static if(!is(typeof(aSD):VariableWrapper)){VariableWrapper _=new VariableWrapper(symbol("a."));}`
		  `static if(!is(typeof(St):VariableWrapper)){VariableWrapper St=new VariableWrapper(symbol("~"));}`
		  `static if(!is(typeof(SDSDSD):VariableWrapper)){VariableWrapper Se=new VariableWrapper(symbol("..."));}`
		  `static if(!is(typeof(result):ExpressionWrapper)){ExpressionWrapper result;}`
		  
anonymous
()
Ответ на: комментарий от anonymous
`list(symbol("define"),symbol("!"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("$"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("%"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("&"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("*"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("+"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("-"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("/"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol(":"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("<"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("="),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol(">"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("?"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("^"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("_"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `list(symbol("define"),symbol("~"),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment);`
		  `result=new ExpressionWrapper(`
		  `list(symbol("define"),symbol("..."),number(1)).compile(.scheme.common.compileEnvironment).evaluate(.scheme.common.runtimeEnvironment));`
	);
}
anonymous
()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.