Ես ուզում եմ տեսնել, թե որքան երկար է ցուցակը, բայց առանց length ֆունկցիայի օգտագործման: Ես գրել եմ այս ծրագիրը և այն չի աշխատում: Միգուցե կարող եք ասել, թե ինչու: Շնորհակալություն
let y = 0
main = do
list (x:xs) = list (xs)
y++
list :: [Integer] -> Integer
list [] = y
(fst . last . zip [0..] . tails)-ը (տես Ինչպես մտածել ֆունկցիոնալ): 16.05.2017 Ձեր ծրագիրը բավականին «հրամայական» տեսք ունի. դուք սահմանում եք y փոփոխականը, այնուհետև ինչ-որ կերպ գրում եք do, որը կանչում է (?) list ֆունկցիան (?), որն ինքնաբերաբար կարծես «վերադարձնում է y»-ը և այնուհետև դուք ուզում եմ ավելացնել y:
Haskell (և առավել ֆունկցիոնալ և դեկլարատիվ) լեզուներն այդպես չեն աշխատում.
do-ը սովորաբար օգտագործվում է մոնադների համար, մինչդեռ length-ը մաքուր ֆունկցիա է,let-ը շարահյուսական կոնստրուկցիա է՝ արտահայտության շրջանակում փոփոխական սահմանելու համար,Haskell-ը (կամ որևէ ֆունկցիոնալ լեզու) ծրագրավորելու համար դուք պետք է «մտածեք ֆունկցիոնալ». մտածեք, թե ինչպես կլուծեիք խնդիրը մաթեմատիկական եղանակով՝ օգտագործելով միայն ֆունկցիաները:
Մաթեմատիկայի մեջ դուք կասեք, որ [] դատարկ ցուցակը հստակորեն ունի 0 երկարություն: Ավելին, եթե ցուցակը դատարկ չէ, կա առաջին տարրը («գլուխը») և մնացած տարրերը («պոչը»): Այդ դեպքում արդյունքը մեկ գումարած պոչի երկարությունն է։ Մենք կարող ենք դա վերածել մաթեմատիկական արտահայտության մեջ, ինչպիսին է.
Այժմ մենք կարող ենք հեշտությամբ թարգմանել այդ գործառույթը հետևյալ Haskell կոդի մեջ.
ownLength :: [a] -> Int
ownLength [] = 0
ownLength (_:xs) = 1 + ownLength xs
Այժմ Haskell-ում սովորաբար օգտագործվում են կուտակիչներ՝ պոչի ռեկուրսիա կատարելու համար. դուք փոխանցում եք պարամետր ռեկուրսիվ զանգերի միջոցով և ամեն անգամ, երբ թարմացնում եք: փոփոխականը։ Երբ հասնում եք ձեր ռեկուրսիայի ավարտին, դուք վերադառնում եք, երբեմն որոշ հետմշակումից հետո, կուտակիչ:
Այս դեպքում կուտակիչը կլինի մինչ այժմ տեսած երկարությունը, այնպես որ կարող եք գրել.
ownLength :: [a] -> Int
ownLength = ownLength' 0
where ownLength' a [] = a
ownLength' a (_:xs) = ownLength' (a+1) xs
Կարծես դու դեռ մտածում ես հրամայական ձևով (ոչ ֆունկցիոնալ ձևով): Օրինակ:
y++)y) list ֆունկցիայի մարմնումԱհա ձեր խնդրի հնարավոր լուծումը.
main = print $ my_length [1..10]
my_length :: [Integer] -> Integer
my_length [] = 0
my_length (_:xs) = 1 + my_length xs
Կարող եք նաև գործարկել այս կոդը այստեղ՝ http://ideone.com/mjUwL9:
Խնդրում ենք նաև նկատի ունենալ, որ կարիք չկա պահանջելու, որ ձեր ցուցակը բաղկացած լինի Integer արժեքներից: Փաստորեն, դուք կարող եք ստեղծել ձեր ֆունկցիայի շատ ավելի «ագնոստիկ» տարբերակը՝ օգտագործելով հետևյալ հայտարարությունը.
my_length :: [a] -> Integer
Այս ֆունկցիայի իրականացումը կախված չէ ցանկի տարրերի տեսակից, ուստի այն կարող եք օգտագործել ցանկացած տեսակի ցանկի համար: Ի հակադրություն, դուք չեք կարող այդքան լիբերալ լինել, օրինակ, my_sum ֆունկցիայի համար (պոտենցիալ ֆունկցիա, որը հաշվարկում է տվյալ ցանկի տարրերի գումարը): Այս իրավիճակում դուք պետք է սահմանեք, որ ձեր ցուցակը բաղկացած է որոշ թվային տիպի տարրերից:
Վերջում ես ուզում եմ ձեզ մի ֆանտաստիկ գիրք առաջարկել Haskell ծրագրավորման մասին՝ http://learnyouahaskell.com/chapters.
Մյուս պատասխաններն արդեն գեղեցիկ կերպով բացատրել են համապատասխան ֆունկցիոնալ մոտեցումը: Կարծես թե ավելորդ է, բայց ահա length ֆունկցիան իրականացնելու ևս մեկ եղանակ՝ օգտագործելով միայն հասանելի ավելի բարձր կարգի գործառույթները:
my_length :: [a] -> Integer
my_length = foldr (flip $ const . (+1)) 0
foldr (const (1+)) 0: 16.05.2017 Հավանաբար ամենապարզ ձևը բոլոր տարրերը 1-ի վերածելն է, այնուհետև նոր տարրերը գումարելը.
sum . map (const 1)
Ավելացված արագության համար.
foldl' (+) 0 . map (const 1)
lengthը որպես մոնադիկ գործողություն.length xs = sum $ do {xs; return 1}16.05.2017