Может ли быть Segmentation Fault в Haskell?

Конечно

но непонятно как такое замутить

Вспомнил про патч ведра для поддержки малвари ;).

unsafeCoerce

unsafe это чит какой-то
не валидный пример

nullPtr

даже нехачкеллисту понятно что тут что-то очень нехорошее
нужен неочевидный пример

Ответ очевиден.

Да тебе не угодить. «То ему не нравится, это ему не нравится.»

https://ghc.haskell.org/trac/ghc/ticket/9416 - менее очевидный :)

https://ghc.haskell.org/trac/ghc/search?q=SIGSEGV - еще менее очевидные.

нужен неочевидный пример

Оно ведь может из сторонней (а то и сишной) либы прийти.

тут уже не очень понятно что происходит
Засчитано!
спасибо

нужен неочевидный пример

Оно ведь может из сторонней (а то и сишной) либы прийти.

ну, это как раз таки очевидно :)

Может. Haskell реализует именно эту половину Common Lisp.

Ты думаешь у тебя получается сферический код в вакууме? Хотя если это Хаскель…

http://hackage.haskell.org/package/base-4.8.1.0/docs/Foreign-Marshal-Alloc.html

Может, но зачем?

Без использования всяких unsafe по идее не может. Разве что стек переполнится, правда не знаю, как это в хаскеле реализовать.

Рекурсивный вызов функции без хвостовой рекурсии.

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

Да пожалуйста

Prelude> let test x= test(x) - 1
Prelude> test 5
<interactive>: out of memory (requested 1048576 bytes)

А почему он пишет out of memory, а не ошибку переполнения стека?

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

А разве на стек выделяется не отдельная память?

Это не стек кончается, а куча из-за ленивых вычислений.

Может, но надо уметь его делать

ты оба моих примера привел, не честно так

Где ты увидел кучу? В данном примере происходит передача параметров через стек, чем стек и забивается. Ну и ленивых вычислений в упор не вижу тоже.

А разве на стек выделяется не отдельная память?

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

Почитай, как хаскель работает. Там всё ленивое.

Это баг GHC. Скорее всего исправлен этим коммитом:

http://git.haskell.org/ghc.git/commitdiff/3bebf3c2d92e6defc6d17ffa237cc4a9cad...

Код должен генерить haskell-исключение, которое можно споймать. В ghc-7.10.2 работает так:

$ ghc -e 'let f x = f x - 1 in f 5'

GHC stack-space overflow: current limit is 33624 bytes.
Use the `-K<size>' option to increase it.

$ ghc -XScopedTypeVariables -e 'let f x = f x - 1 in Control.Exception.evaluate (show $ f 5) `Control.Exception.catch` (\(e :: Control.Exception.SomeException) -> print ("exception:", e) >> return "I sort of Failed")'

("exception:",stack overflow)
"I sort of Failed"

Без использования всяких unsafe по идее не может.

Foreign.* — это unsafe? А Typeable?

Foreign.* — это unsafe?

Конечно.

А Typeable?

Не знаю, что это такое.

Safe расширение GHC ограничивает механизмы, которыми можно в рантайме сломать типы:

https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/safe-haskell....

https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/safe-haskell....

In the safe language dialect we restrict the following features:

ForeignFunctionInterface — This is mostly safe, but foreign import declarations that import a function with a non-IO type are disallowed. All FFI imports must reside in the IO Monad.

RULES — As they can change the behaviour of trusted code in unanticipated ways, violating semantic consistency, they are restricted in function. Specifically any RULES defined in a module M compiled with -XSafe are dropped. RULES defined in trustworthy modules that M imports are still valid and will fire as usual.

OverlappingInstances — This extension can be used to violate semantic consistency, because malicious code could redefine a type instance (by containing a more specific instance definition) in a way that changes the behaviour of code importing the untrusted module. The extension is not disabled for a module M compiled with -XSafe but restricted. While M can define overlapping instance declarations, they can only overlap other instance declaration defined in M. If in a module N that imports M, at a call site that uses a type-class function there is a choice of which instance to use (i.e. an overlap) and the most specific instances is from M, then all the other choices must also be from M. If not, a compilation error will occur. A simple way to think of this is a same origin policy for overlapping instances defined in Safe compiled modules.

Data.Typeable — We restrict Typeable instances to only derived ones (offered by GHC through the -XDeriveDataTypeable extension). Hand crafted instances of the Typeable type class are not allowed in Safe Haskell as this can easily be abused to unsafely coerce between types.

Safe расширение GHC

Спасибо. Я верно понимаю, что при использовании Safe не должно быть возможности получить Segfault?

При использовани только Safe модулей - да.