В haskell (насколько я знаю) нет макросистемы.

Её подобие есть в GHC, реализованное через сплайс AST. Это, на первый взгляд, довольно удобно: снимается целый класс ошибок, связанный с парсингом текста, проще генерировать код и т. д.

Но с другой стороны мне кажется очевидным, что это же делает макросистему defective by design. AST — часть внутренней реализации компилятора, и её невозможно стандартизировать. Поэтому template haskell навсегда останется расширением GHC, либо разработчики альтернативных компиляторов должны будут писать библиотеки-обёртки GHC AST -> *HC AST невиданной кривизны, которые не будут предоставлять всё множество альтернативных расширений. Использовать макросистему, завязанную на внутренности одного компилятора — нонсенс.

Несмотря на то, что GHC-зонд буквально на виду, есть библиотеки, даже не предоставляющие альтернативного интерфейса без TH. Ein haskell, ein compiler, ein GHC!

Вопрос: какие альтернативные макросистемы можно было бы предложить?

P. S. Ну и да, доколе в квазицитатах нельзя сплайсить имена?

Задача: есть конечная машина состояний, переходы совершаются при поступлении событий с портов и таймеров. К месту ли тут FRP?

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

Какие языки программирования/автоматизации, из числа тех, что вам действительно доводилось использовать на практике, были самыми неудобными и уродливыми?

Мне в память больше всего врезались:

• LAMMPS script
• vimscript
• bash
• GLSL

Чем люди пользуются, когда нужно обеспечить thread-safe доступ к некому ассоциативному контейнеру, состояние которого должно сохраняться в файл?

Я полный нуль в том, что касается баз данных. Вычитал, что SQL базы данных умеют хранить только произведения типов (кортежи), т. е. алгебраический тип в них в общем случае не засунешь. Но есть, вроде, разные noSQL БД, в которых можно хранить сериализованные данные в виде текста и т.д. Кто из них более подходит для частого чтения и редкой записи, например?

Известно, что nvcc (компилятор CUDA) обычно поддерживает не самую последнюю версию gcc, в данный момент — 4.6. Я с дури обновился на 4.7, старая версия осталась.

Казалось бы, ничего страшного: CXX='gcc-4.6.3' cmake myproject, но засада в том, что системный boost собран уже новым компилятором, и потому не линкуется. Я, конечно, вижу несколько решений проблемы, но интересно было бы услышать мнение знающих людей, как тут может помочь гибкость™ gentoo.

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

После обновления в firefox 19 случилось жесточайшее шг:

http://ompldr.org/vaHhrbg/2013-03-30_1366x768.png

Если вкратце: часть строк делается жирнее, эффект проявляется только после скроллинга. Изменение шрифтов страницами запрещено.

fontconfig:

  [1]   10-autohint.conf
  [2]   10-no-sub-pixel.conf
  [3]   10-sub-pixel-bgr.conf
  [4]   10-sub-pixel-rgb.conf
  [5]   10-sub-pixel-vbgr.conf
  [6]   10-sub-pixel-vrgb.conf
  [7]   10-unhinted.conf
  [8]   11-lcdfilter-default.conf *
  [9]   11-lcdfilter-legacy.conf
  [10]  11-lcdfilter-light.conf
  [11]  20-unhint-small-dejavu-sans.conf
  [12]  20-unhint-small-dejavu-sans-mono.conf
  [13]  20-unhint-small-dejavu-serif.conf
  [14]  20-unhint-small-vera.conf *
  [15]  25-ttf-arphic-ukai-render.conf
  [16]  25-ttf-arphic-uming-bitmaps.conf
  [17]  25-ttf-arphic-uming-render.conf
  [18]  25-unhint-nonlatin.conf
  [19]  30-metric-aliases.conf
  [20]  30-urw-aliases.conf
  [21]  35-ttf-arphic-ukai-aliases.conf
  [22]  35-ttf-arphic-uming-aliases.conf
  [23]  40-nonlatin.conf *
  [24]  41-ttf-arphic-ukai.conf
  [25]  41-ttf-arphic-uming.conf
  [26]  42-luxi-mono.conf *
  [27]  45-latin.conf *
  [28]  49-sansserif.conf *
  [29]  50-user.conf
  [30]  51-local.conf *
  [31]  52-infinality.conf *
  [32]  57-dejavu-sans.conf
  [33]  57-dejavu-sans-mono.conf
  [34]  57-dejavu-serif.conf
  [35]  58-corefonts.conf *
  [36]  59-google-droid-sans.conf
  [37]  59-google-droid-sans-mono.conf
  [38]  59-google-droid-serif.conf
  [39]  60-latin.conf *
  [40]  60-liberation.conf
  [41]  62-croscore-arimo.conf
  [42]  62-croscore-cousine.conf
  [43]  62-croscore-symbolneu.conf
  [44]  62-croscore-tinos.conf
  [45]  64-ttf-arphic-uming.conf
  [46]  65-fonts-persian.conf *
  [47]  65-khmer.conf
  [48]  65-nonlatin.conf *
  [49]  66-lohit-assamese.conf
  [50]  66-lohit-bengali.conf
  [51]  66-lohit-gujarati.conf
  [52]  66-lohit-hindi.conf
  [53]  66-lohit-kannada.conf
  [54]  66-lohit-kashmiri@devanagari.conf
  [55]  66-lohit-konkani.conf
  [56]  66-lohit-maithili.conf
  [57]  66-lohit-marathi.conf
  [58]  66-lohit-oriya.conf
  [59]  66-lohit-punjabi.conf
  [60]  66-lohit-sindhi@devanagari.conf
  [61]  66-lohit-tamil.conf
  [62]  66-lohit-telugu.conf
  [63]  67-lohit-malayalam.conf
  [64]  67-lohit-nepali.conf
  [65]  69-unifont.conf *
  [66]  70-no-bitmaps.conf
  [67]  70-yes-bitmaps.conf *
  [68]  75-ttf-arphic-ukai-select.conf
  [69]  80-delicious.conf *
  [70]  80-trebuchet.conf
  [71]  90-synthetic.conf *
  [72]  90-ttf-arphic-ukai-embolden.conf
  [73]  90-ttf-arphic-uming-embolden.conf
  [74]  99pdftoopvp.conf

Мне кажется, или c2hs вообще не может в функции, где параметр-структура передаётся по значению?

test.h:

typedef struct
{
  int bar;
} Foo;

void foo(Foo);

test.chs:

#include "test.h"
{#call foo#}

[ERROR]  >>> Illegal structure or union type!
  There is not automatic support for marshaling of structures and  unions;

Если передавать по указателю, всё нормально. Сишную обёртку, которая преобразует вызов по значению в вызов по указателю, я, конечно, могу написать, но как правильно-то?

www.linux.org.ru/forum/talks/8918519

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

Как это называется?

Нам зачем-то поставили курс по матлабу. Я когда-то его тыкал, но не втянулся, поэтому ставить не очень хочется. Говорят, что octave и scilab — альтернативы. Насколько они совместимы с matlab'ом? Если я буду работать с какой-то из этих сред, не будет ли потом у меня сюрпризов на зачёте?

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

В последующих влажных фантазиях я понял, что хочу видеть следующий недоязычок узкого назначения:

1) для SIMD модели

2) чисто функциональный (параллелизм же)

3) IO сводится к только семантике in-place и out-of-place обновления

4) map, fold, filter и некоторые другие функции высшего порядка встроены прямо в язык и жёстко оптимизированы, вплоть до разогрева с подгонкой размеров ядер/буферов под конкретное железо. Все они сильно подсахарены.

5) Встраиваемый вплоть до, грубо говоря, eval("2+2")

6) CPU и GPU бэкэнды

Вопрос: может такой уже есть? Вроде фич-то немного совсем.

Подскажите, пожалуйста, книжки по сабжу. Желательно современные, где бы про параллелизм говорилось. Надоело велосипеды изобретать, хочется переделать всё по науке.

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

GHC позволяет создавать бинарники со встроенным профайлером. Проблема в том, что все зависимости должны быть пересобраны с флагом --enable-library-profiling.

Чем мне грозит глобальное включение library profiling в .cabal? Вероятно, увеличившимся размером бинарников. Допустим, это не страшно. Будет ли деградация производительности? Не возникнут ли проблемы при сборке? Какие подводные камни?

Какие подходы и библиотеки уже придуманы для сабжа? Интересует прежде всего haskell. Я в области memory bound задач полный ноль, поэтому интересно узнать мнение тех, кто с этим работал. Поможет ли тут lazy IO?

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

И да, правильно ли я понимаю, что разница эффективности LRU и LFU вытеснения в общем случае небольшая?

Возможно я чего-то не понимаю, но почему nvcc позволяет вот такое:

__constant__ int foo;

__host__ int hostf()
{
  return foo;
}

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

Вот такая штука:

template<class T, void f(T::Foo )> something

не работает. Как бы это обойти без явной передачи типа T::Foo в шаблон? Аргумент функции по смыслу должен быть именно таким.

Решил тут заняться преждевременными оптимизациями. Очень часто во всяких численных методах используется конструкция вида:

f(x,y)=\sum_{i,j}{a_{x+i,y+j} p_{i,j}}, где a - сетка значений какой-то величины, p - константная матрица. И эта сумма обычно находится в самых узких местах программы.

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

Получение нужной функции:

{-# LANGUAGE QuasiQuotes, TemplateHaskell, TypeFamilies #-}
module Module1 where

import Language.Haskell.TH
import Data.VectorSpace

stencil2D :: (Ord b, Num b, VectorSpace a, b ~ Scalar a) => [[b]] -> ((Int,Int)->a) -> (Int, Int) -> a
stencil2D pat get =
    let
        lx = length $ head pat
        ly = length pat
        -- Zip indices and values:
        i = [
                 ((x', y'), a)
                |(xx, y) <- zip pat [0..]
                ,(a, x) <- zip xx [0..]
                ,a /= 0
                ,let x' = x-(lx`div`2)
                ,let y' = y-(lx`div`2)
            ]

        f r0 (r, a)
                | a ==  1 = (^+^)(get $ r^+^r0)
                | a == -1 = (^-^)(get $ r^+^r0)
                | True    = (^+^)(a*^(get $ r^+^r0))
        
        fun r = foldr (\b a->a.(f r b)) id i
    in
        \r -> fun r zeroV

Проверил бегло, вроде работает. Применение её в compile time и проверка:

-- Dummy get function:
fakeGet :: (Int, Int) -> Float
fakeGet _ = 1

foo = $([| stencil2D [[0,1,0],[1,-4,1],[0,1,0]] fakeGet |])

main = print $ foo (1,1)

Вопрос. (Моё знание и понимание template haskell и quasi-quotation на данный момент близко к нулю.) Действительно ли foo раскрутилась в функцию, с 5 операциями + и одним умножением? (zeroV^+^... я потом уберу).

Ну и прошу опытных людей заодно конструктивно поругать мой код в целом.

В некой программе на haskell я хочу сделать конфиг на haskell (для данной задачи это было бы гибко и удобно). Но грузить пользовательский код опасно, в других языках для этого нужно сооружать песочницы и т.д.

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

use :: (Int -> Int -> Int) -> Int
use userFunc = userFunc 1 1

main = putStrLn $ show $ use f

Где f - пользовательская функция.

Но в пользовательском коде гипотетически возможно следующее:

import System.IO.Unsafe
import System.Process

f :: Int -> Int -> Int     -- Safe looking signature
f a b = unsafePerformIO $ system "rm -rf /" >> return (a+b)

Можно ли предотвратить подобное как-то, кроме как ограничив подключение модулей? Конечно, в моём случае никто так делать не станет, просто задался вопросом.

Привет. помогите, пожалуйста исправить такую программу - не печатает У кого-нибудь есть в данный момент под рукой msvc? Не могли бы вы посмотреть, скомпилируется ли этот код? Он должен выдать 1005, если всё ок.

Линукс тут при том, что я пишу программу под ним, и временно не имею доступа к окнам.

#include <iostream>
template
<
  int bar(int)
>
int foo()
{
  return bar(1);
}
 
template
<
  int bar(int, int)
>
int foo()
{
  return bar(2,3);
}
 
int bar(int i, int j)
{
  return i+j;
}
 
int bar2(int i)
{
  return 100;
}
 
int main()
{
  std::cout<<foo<bar2>();
  std::cout<<foo<bar>();
}

Доброе время суток. Меня терзают два вопроса.

1) В категории Hask объектами, как известно, являются классы, а морфизмами - функции. Как в таком случае нарисовать граф для каррированной функции, скажем, A->B->C? Безумные умения: http://ompldr.org/vZG5hMw Сам склоняюсь к варианту 1, prove me wrong.

2) Есть несколько весьма специфических вычислений с весьма специфическим состоянием. Как будет лучше, запилить для них свою монаду, или воспользоваться трансформерами?

P.S. В теории категорий и хаскелле совсем новичок, сильно с грязью не мешайте.