Ekspresja chętna w Frege, ale leniwa w Haskell?

Question

W Haskell, następujące drukuje kod "[1,2,3,4,5":

foo = take 10 $ show $ numbersFrom 1 where 
    numbersFrom start = start : numbersFrom (start + 1) -- could use [1..] 

Ale w Frege, rzuca OutOfMemoryError z następującego kodu:

foo = take 10 $ unpacked $ show $ numbersFrom 1 where 
    numbersFrom start = start : numbersFrom (start + 1) 

Tutaj jedyną różnicą jest funkcja unpacked, która jest niezbędna do konwersji z String na [Char], a funkcja FWIW, funkcja unpacked jest gorliwa. Dlaczego całe wyrażenie nie może być leniwy, jak w Haskell? Czy jest możliwe osiągnięcie czegoś podobnego do Haskella w Frege?

Answer 1

Nie użyłem Fregego, ale wydaje mi się, że jeśli unpacked jest ścisłe, to jego argument nie powinien być nieskończoną listą. Wypróbuj unpacked $ take 10 zamiast take 10 $ unpacked.

Answer 2

Nie wiem Frege, ale zgodnie z definicją języka String jest java.lang.String, więc nie można zbudować nieskończenie długich ciągów (problem z braku pamięci prawdopodobnie nie ma nic wspólnego z unpack).

Bo wiesz każdy element numbersFrom 1 zostaną pokazane jako co najmniej 1 znak, a następnie można nadmierne zbliżenie wielkości listy, aby pokazać, następnie rozpakować, a następnie podjąć szereg pożądanych znaków:

foo = take 10 $ unpacked $ show $ take 10 $ numbersFrom 1 where 
    numbersFrom start = start : numbersFrom (start + 1) 

lub bardziej ogólnie:

n = 10 -- number of characters to show 
m = 1 -- minimum (map (length . show) xs) for some type of xs 
foo :: a -> [Char] 
foo = take n . unpack . show . take ((n+m-1) `div` m) . someEnumeration 
    where 
    someEnumeration :: a -> [a] 
    someEnumeration = undefined 

Jeśli wyliczenie jest drogie wtedy można zacząć biorąc pod uwagę liczbę przecinkami, spacjami, itp i zmniejszyć argument drugiej take, ale masz pomysł.

Answer 3

To nie zadziała z powodu nieskończonego łańcucha, który nie jest (produkowany) przez show. Potrzebowałbyś jakiejś funkcji pomocnika, która zamienia listę na listę Char.

Prawdopodobnie dobrze byłoby mieć do tego standardową funkcję.

---

Edycja 22 lutego 2013

Klasa Show ma teraz nową metodę:

{-- 
    'showChars' addresses the problem of 'show'ing infinite values. 
    Because 'show' has type 'String' and 'String' is atomic, this would 
    try to create a string with infinite length, and hence is doomed to fail. 

    The default definition is 

    > showChars = String.toList . show 

    This is ok for all finite values. But instances for recursive types 
    should implement it in a way that produces a lazy list of characters. 

    Here is an example for the list instance: 

    > showChars [] = ['[', ']'] 
    > showChars xs = '[' : (tail [ c | x <- xs, c <- ',' : showChars x ] ++ [']']) 

-} 
showChars :: show -> [Char] 
showChars = String.toList . show 

Kod Haskell, który doprowadził do OutOfMemoryError Teraz można zapisać jako:

(println . packed . take 10 . showChars) [1..] 

Answer 4

Dodawanie do innych odpowiedzi,

Od show zwraca java.lang.String, nie można wyświetlić nieskończonej listy. Pomyślałem więc, że mógłbym napisać inną wersję programu, aby zamiast tego zwrócić numer [Char]. Oto, co wymyśliłem i działa.

frege> :paste 
class AltShow a where 
    altshow :: a -> [Char] 

instance AltShow AltShow a => [a] where 
    altshow [] = [] 
    altshow xs = concat $ (['['] : intersperse [','] ys) ++ [[']']] where 
    ys = map altshow xs 

instance AltShow Int where 
    altshow = unpacked <~ show 

intersperse :: a -> [a] -> [a] 
intersperse _ [] = [] 
intersperse _ (x:[]) = [x] 
intersperse sep (x : y : []) = 
    x : sep : y : [] 
intersperse sep (x : y : rest) = 
    x : sep : y : sep : intersperse sep rest 
:q 
Interpreting... 

frege> altshow [1, 10, 2, 234] 
res3 = ['[', '1', ',', '1', '0', ',', '2', ',', '2', '3', '4', ']'] 
frege> :t res3 
res5 :: [Char] 
frege> packed res3 
res6 = [1,10,2,234] 
frege> :t res6 
res7 :: String 

Teraz kod w pytaniu staje się podobny do Haskell i nie eksploduje z OutOfMemoryError:

frege> :paste 
foo = take 10 $ altshow $ numbersFrom 1 where 
    numbersFrom start = start : numbersFrom (start + 1) 
:q 
Interpreting... 

frege> foo 
res9 = ['[', '1', ',', '2', ',', '3', ',', '4', ',', '5'] 
frege> packed foo 
res11 = [1,2,3,4,5 

Answer 5

Krótka odpowiedź: Struny są surowe w Frege, ale leniwy w Haskell.

Listy są leniwe w obu językach. Ale w Fregacie ciągi nie są listami.