Язык для работы с массивами

Самопальный DSL — твой выбор!

Любой.

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

APL, бгг. Ты же это хотел услышать? Или J.

Сначала надо изучить достижения общества в этом направлении чтобы создавать что-то своё. Для этого я и создал этот тред.

Нет. Я хотел услышать что-то мне незнакомое.

Тогда вопрос надо было задавать как-то по-другому, а не «самый лаконичный».

А вот о J слышу впервые.

octave

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

Черт, анонiмус сменил ник :/

Python. Можно Luajit, если нужна скорость.

Его просто очередной раз забанили.

Скажи, анонимус, а есть ли ООП-язык, в котором программист - это тоже объект?

интересная идея. Это что-то типа того, что не ты пишешь программу, а программа пишет тебя.

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

Если говорить про современные реализации, то J всё-таки сложноват, поэтому рекомендую смотреть на K:

http://kparc.com/ http://kparc.com/k.txt

https://github.com/JohnEarnest/ok https://github.com/JohnEarnest/ok/blob/gh-pages/docs/Manual.md

ничего более выразительного, чем APL

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

Есть еще его продвинутая версия - Q!.
Он вроде был в одно время и самый быстрый по работе с массивами.

Любой.

matlab

Интересно, какой интерфейс и с какими операциями, по-твоему, должен быть у массива, и в чём именно он отличается от алгебры в K?

Ну и про «любой тип» «объектов», с которыми без твоего ООП нельзя никак «взаимодействовать», тоже хотелось бы узнать подробнее.

простенький пример

MyList := List clone do(
  add := method(arg,
    if(arg isKindOf(Number), self mapInPlace(x, x + arg); return  )
    if(arg isKindOf(List), self mapInPlace(key, value, value +( arg at(key) )); return  )
    if(arg isKindOf(Sequence), self push(arg)  )
  )
)


l := MyList clone


l push(1)
l push(1)
l push(1)


l add(1)
l println

l add(list(1, 2, 3))
l println

l add("foo")
l println


#>>>> list(2, 2, 2)
#>>>> list(3, 4, 5)
#>>>> list(3, 4, 5, foo)

Python + numpy

Матлаб. Запись массивов без запятой: [1 0 0]. Оператор транспонирования матрицы в один символ: '

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

Ну тогда это Smalltalk, разумеется!

  Iterable
    Collection
      Bag
      HashedCollection
        Dictionary
          BindingDictionary
            AbstractNamespace
              Namespace
              RootNamespace
                SystemDictionary
          LookupTable
            IdentityDictionary
            MethodDictionary
            WeakValueLookupTable
              WeakValueIdentityDictionary
          WeakKeyDictionary
            WeakKeyIdentityDictionary
        Set
          IdentitySet
          WeakSet
            WeakIdentitySet
      MappedCollection
      SequenceableCollection
        ArrayedCollection
          Array
            WeakArray
          ByteArray
          CharacterArray
            String
              Symbol
            UnicodeString
          CompiledCode
            CompiledBlock
            CompiledMethod
          Interval
          LargeArrayedCollection
            LargeArray
            LargeByteArray
            LargeWordArray
          WordArray
        LinkedList
          Semaphore
        OrderedCollection
          RunArray
          SortedCollection
    Stream
      FileDescriptor
        FileStream
      Generator
      ObjectDumper
      PositionableStream
        ReadStream
        WriteStream
          ReadWriteStream
      Random
      TextCollector

да! matlabу нету равных.

Фортран. Все прочие от лукавого.

Haskell, вестимо.

[ (a,b,c) | a <- [1..10], b <- [a..10], c <- [b..10], a^2+b^2=c^2 ]

Какой язык самый лучший для работы с массивами?

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

К.О. утверждает, что это не массивы. А вот работа с массивами в Haskell как раз некрасива.

По теме — плюсую J.

Ваш К.О. слишком самоуверен:

Prelude Data.Vector> [ (a,b,c) | a <- [1..10], b <- [a..10], c <- [b..10], a^2+b^2 == c^2 ] :: Vector (Int, Int, Int)
fromList [(3,4,5),(6,8,10)]

К.О. утверждает, что это не массивы.

Просили не отвлекаться на implementation details.

Определение массива К.О. не забыл внести в студию. А то так-то всякие array theory есть.

Особенно по производительности... хотя нет, наверное бэйсик еще тормознутее.

Не смог найти в этом комментарии ничего кроме воды

Сплав лучших черт APL и Smalltalk вижу я.

А что именно тебя интересует? Всякие map, reduce, filter, iter, sort и лямбды есть сейчас во всех мейнстримных языках.

matlab, fortran

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

я видел эту производительность в сравнении с плюсами.
красота лаконичность требует жертв!

Тред не читал. Ку!

nezamudich Не работает без обмаза расширениями. ОП просил красивую реализацию.

Miguel, асимптотики — это не implementation detail.

Не работает без обмаза расширениями. ОП просил красивую реализацию.

Не-не-не - всё нормально. Расширенный язык это тоже ведь язык.

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

Ну и зачем это писать руками, и так ведь уже есть.

 ::l:1 1 1
1 1 1

if(arg isKindOf(Number), self mapInPlace(x, x + arg); return )

Ок.

 
 ::l+:1
2 2 2

if(arg isKindOf(List), self mapInPlace(key, value, value +( arg at(key) )); return )

Ок!

 ::l+:1 2 3
3 4 5

if(arg isKindOf(Sequence), self push(arg) )

Ой! А может, лучше всё-таки не перегружать арифметическую операцию сложения таким странным образом? Как же мне теперь прибавить к моему списку вектор, скажем? Лучше как-нибудь по-другому обозначить конкатенацию, мне кажется:

 ::l,:`foo
(3;4;5;`foo)

Смысл нормальных языков в том, что в них уже есть самая лучшая и продуманная ортогональная алгебра операций, и ничего не надо «перегружать» — станет только хуже (как в твоём примере, где ты перепутал сложение с конкатенацией).

Про Матрикс Лаборатори выше уже писали, и про Октаву, бесплатного пророка ее.

Practical Extraction and Report Language

асимптотики — это не implementation detail.

Вполне себе, ибо скорость работы явным образом проигнорирована топикстартером.

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

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

полиморфизма
гибкости в плане конфигурирования
наследования/специализации

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

муттабельность еще есть

я не знаю, что такое «муттабельность», но если допустить, что ты имеешь в виду изменяемость значений (mutability), то конечно в моём примера она есть — значение l меняется после каждой операции (иначе, например, результатом последней было бы (1;1;1;`foo))

Это просто был пример того, как я пилю то что хочу, тогда как обычный хомячек, обмазывается тем говном, которое ему соизволил предоставить дядя. Дело не в алгебрах сраных, пример простой, он показывает не «что», а «как». Насчет муттабельности ошибся, сорри.