W dniu piątek, 4 stycznia 2019 01:13:33 UTC+1 użytkownik fir napisał:
> > Ogólnie derywację tego programu mam dość dogłębnie opisaną
> > w pierwszym rozdziale "Pamphletu":
> > https://github.com/panicz/pamphlet/raw/master/pamphl
et.pdf
> >
> > W praktyce zapisałbym go raczej np. tak (jeżeli język
> > wspierałby leniwą ewaluację):
> >
> > (sum (map square (initial 7 (only prime? numbers))))
> >
> > gdzie "map", "only" i "initial" są zdefiniowane tak:
> >
>
> jakos nie wyglada mi to na prostsze niz wersja w c

To nie jest tylko kwestia "wyglądania".
Do zrozumienia tego kodu wystarczy stosować rozumowanie
"podstawieniowe", które wcześniej pokazałem.
Do zrozumienia Twojego kodu w C oprócz podstawienia (które też
jest potrzebne, bo zdefiniowałeś funkcję z parametrem) trzeba
też rozumieć takie rzeczy, jak przepływ sterowania albo
operator przypisania.

> a co to jest tam wyzej sum square (inty?) prime? (funkcja?) i numbers (???)

jak mamy wyrażenie
(sum (map square (initial 7 (only prime? numbers))))

to sygnatury typów będą następujące:

sum :: Num a => [a] -> a

oznacza to, że funkcja "sum" bierze listę elementów o jakimś typie
numerycznym (czyli takim, dla którego zdefiniowany jest operator dodawania)
i zwraca element numeryczny. Operator :: czytamy jako "jest typu".
Rzeczy po lewej stronie operatora "=>" to tzw. "ograniczenia typów",
zaś to po prawej jest już konkretną sygnaturą. [a] oznacza listę elementów
typu a.

map :: (a -> b) -> [a] -> [b]

map jest funkcją, która pobiera jakąś funkcję jednoargumentową
oraz listę elementów, do których można zastosować tę funkcję,
i zwraca listę elementów typu wynikowego funkcji.

Warto zwrócić uwagę, że choć nasza percepcja jest taka, że "map" jest
funkcją dwuargumentową, z sygnatury typów możemy wyczytać, że jest to
funkcja pobierająca jakiś argument (funkcję) i zwracająca funkcję
pobierającą jakiś argument (listę), czyli - mówiąc w pewnym uproszczeniu
wszystkie wieloargumentowe funkcje w Haskellu są tak naprawdę jednoargumentowymi
funkcjami zwracającymi funkcje (ten ficzer nosi nazwę "Currying",
albo - jak chciała polska tłumaczka książki "Język C++" Stroustrupa
- "doprawianie" (!))

Funkcji square nie definiowaliśmy, ale jej definicja będzie taka:

square x = x * x

a sygnatura typów to oczywiście

square :: Num a => a -> a

(czyli funkcja, która bierze coś numerycznego i zwraca coś numerycznego
tego samego typu).

initial :: Int -> [a] -> [a]

Funkcja only pobiera predykat (czyli funkcję zwracającą wartość Boolowską)
i listę elementów, do których ten predykat daje się zastosować, i zwraca
"pomniejszoną" listę elementów:

only :: (a -> Bool) -> [a] -> [a]

Warto zwrócić uwagę, że system typów Haskella nie pozwala wyrazić tego,
że wynik funkcji jest "pomniejszony" (ale są języki, takie jak Idris
czy Liquid Haskell, w których tego rodzaju własności daje się wyrazić
w sygnaturze typów)

Wreszcie, numbers to po prostu lista liczb całkowitych:

numbers :: [Int]

> nie wyglada to na prostsze od c (dlugie jakies)

Funkcje "only", "map" i "initial" są już predefiniowane.
(tylko "only" nosi tak naprawdę nazwę "filter", a "initial" -- "take").
Ty w C użyłeś np. operatora "for" bez podawania jego definicji
(czego w C zresztą i tak nie dałoby się zrobić).

Gdyby korzystać z gotowych funkcji, i nie chcieć definiować np.
square, to (zakładając dostępność funkcji isPrime) cały program
wyglądałby tak:

foldr (+) 0 (map (^2) (take 7 (filter isPrime [2 ..])))

Warto przy tej okazji powiedzieć nieco o rodzinie funkcji fold.
Zasadnicza idea jest taka, że

fold (*) [a,b,c,d] = a * b * c * d

Jednak powyższe sformułowanie jest niejednoznaczne, bo prawą
stronę można interpretować jako

(a * (b * (c * d)))

albo jako

(((a * b) * c) * d)

albo jako

((a * b) * (c * d))

W praktyce Haskell daje dwie funkcje, foldl i foldr, które
działają w taki sposób:

foldl (*) e [a,b,c,d] = (((e * a) * b) * c) * d
foldr (*) e [a,b,c,d] = a * (b * (c * (d * e)))

Dodatkowy parametr e sprawia, że funkcje mają sensowną wartość
również dla listy pustej, i rozluźnia nieco wymagania narzucane
na operator (*).

(Oczywiście, (*) niekoniecznie oznacza tutaj mnożenie, ale
dowolny operator dwuargumentowy)

> a w to ze to bedzie tak szybkie tez nie do konca wierze

Informatyka to nie jest religia. Jak w coś nie wierzysz, to możesz
sprawdzić. (Tzn. ściśle rzecz biorąc pewnie nie będzie "tak szybkie",
bo Haskellowy runtime ma jakieś tam dodatkowe narzuty)

> przydaloby sie jednak by bylo choc prostsze a nie wyglada

Moim zdaniem jest tak proste, jak tylko się da.

> sam ten kod w c chyab w sumie mozna napisac prsciej
>
>
> int PoliczSumeParuPoczatkowychLiczbPierwszych(int ilu)
> {
> int i = 0, dodano = 0, suma = 0;
>
> for(;;)
> if(jest_liczba_pierwsza(++i))
> {
> suma += i*i ;
> if(++dodano==ilu) return suma;
> }
> }

Dla mnie nie jest to ani trochę prostsze od poprzedniej wersji.