Haskell yeni duyuyorum ve çok kafam karıştıNeredevsİzin verin. Her ikisi de benzer bir amacı sağlamak gibi görünüyor. Arasında bazı karşılaştırmalar okudumNeredevsİzin verinama her ne zaman kullanılır seçici sorun yaşıyorum. Birileri bazı içerik veya başka bir kullanma zamanı gösteren birkaç örnek belki de bulunur musunuz lütfen?

Nerede vs fıkra sadece fonksiyon tanımının düzeyinde tanımlanmış İzin verin. Genellikle, bu izin tanımının kapsamı aynıdır. Tek fark korumaları kullanıldığında. Yan tüm korumaları üzerinde uzanan kapsamı. Buna karşılık, izin ifadesi kapsamında sadece, eğer varsa, geçerli işlev fıkra ve görevlisi.

Haskell Cheat Sheet

Haskell Wiki çok detaylı ve çeşitli durumlarda sağlar ama farazi örnekler kullanır. Onun açıklamaları çok kısa bir acemi için buluyorum.

İzin avantajları:

f :: State s a
f = State $ \x -> y
   where y = ... x ...

Control.Monad.State

nereye başvurur, çünkü çalışmaz desen f eşleşen hiçbir yerde =, x kapsam içinde. Eğer olsaydı aksine, izin başladı, o zaman olmaz sorun yok.

Haskell Wiki on Advantages of Let

f :: State s a
f = State $ \x ->
   let y = ... x ...
   in  y

Nereye avantajları:

f x
  | cond1 x   = a
  | cond2 x   = g a
  | otherwise = f (h x a)
  where
    a = w x

f x
  = let a = w x
    in case () of
        _ | cond1 x   = a
          | cond2 x   = g a
          | otherwise = f (h x a)

Declaration vs. Expression

Haskell wiki bahsederNeredefıkra ise bildirimselİzin verinifade etkileyici. Tarzı dışında nasıl farklı yapabilirim?

Declaration style                     | Expression-style
-------------------------------------- ---------------------------------------------
where clause                          | let expression
arguments LHS:     f x = x*x          | Lambda abstraction: f = \x -> x*x
Pattern matching:  f [] = 0           | case expression:    f xs = case xs of [] -> 0
Guards:            f [x] | x>0 = 'a'  | if expression:      f [x] = if x>0 then 'a' else ...

1. İlk örnek neden olurİzin verinkapsam amaNerededeğil mi?
2. Uygulamak mümkünNeredeilk örnek için?
3. Bazı değişkenlerin gerçek ifadeler teşkil ettiği ve gerçek örnekler için bu geçerli olabilir mi?
4. Başparmak genel bir kural her zaman kullanmak için takip etmek var mı?

Güncelleme:

Bu konuyu daha sonra gelenler için en iyi açıklama burada bulunabilir buldum: "A Gentle Introduction to Haskell".

İfadeler Edelim.

Haskell ifadeler yararlıdır hadi bağlar iç içe geçmiş bir zaman gerekli. Basit bir örnek olarak, düşünün:

let y   = a*b
    f x = (x y)/y
in f c   f d

Bağlamaları bir izin oluşturduğu küme karşılıklı olarak ifade özyinelemeli ve desen bağlamaları tembel olarak kabul edilir örtülü taşıdıkları (yani desenleri ~). Bildirimleri tek tür izin türü imzalar, fonksiyon bağlamaları ve desen bağlamaları.

Where Yan Tümceleri.

Bazen kapsamı için uygundur birkaç üzerinde bağlamaları korunan bir gerektiren denklemler, nerede fıkra:

f x y  |  y>z           =  ...
       |  y==z          =  ...
       |  y<z           =  ...
     where z = x*x

Bu sadece ona kapsayan bir ifade üzerinde kapsamları olan bir ifade ile yapılabilir unutmayın. Where sadece denklemler veya durum ifade bir dizi üst düzeyinde izin verilir. İfadeleri where için geçerli izin bağlamaları aynı özellikleri ve kısıtlamaları. İç içe kapsam bu iki formları çok benzer görünüyor, ama bir ifade bir ifade olduğunu unutmayın, fıkra değil ... nerede ise bir işlev bildirimleri ve durum ifade sözdizimi bir parçası.

1: örneğin sorun

f :: State s a
f = State $ \x -> y
    where y = ... x ...

Bu parametre x. where yan şeyleri tek işlevi f (yok) ve dış kapsamları şeyler parametreleri için başvurabilirsiniz.

2: ilk örnekte where kullanmak İçin, bir ikinci işlevi adlı tanıtabilirsiniz o, bu gibi: parametre olarak x alır

f = State f'
f' x = y
    where y = ... x ...

ya da bu gibi:

f = State f'
    where
    f' x = y
        where y = ... x ...

3: Burada ...'s: . olmadan tam bir örnek

module StateExample where

data State a s = State (s -> (a, s))

f1 :: State Int (Int, Int)
f1 = State $ \state@(a, b) ->
    let
        hypot = a^2   b^2
        result = (hypot, state)
    in result

f2 :: State Int (Int, Int)
f2 = State f
    where
    f state@(a, b) = result
        where
        hypot = a^2   b^2
        result = (hypot, state)

4: let kullanın veya where zevk meselesidir. let bir hesaplama (ön taşıyarak) ve where program akışı (geri hesaplama taşıyarak) vurgulamak vurgulamak için kullanıyorum.