Синтаксис Haskell, ошибки синтаксического анализа для манекенов

Question

сегодня я много читал о Haskell, но эта формация сводит меня с ума. Я хочу как можно скорее понять основные ошибки, чтобы нормально начать кодирование. Функция здесь должна возвращать строку, которая начинается со следующей строки «math Sign», строка (2sdwds+asd)+3 должна возвращать +asd)+3. Вот код

getToNextSign :: String -> String 
getToNextSign str = do 

let mathSigns = ['+' , '-' , '*' , '/' , '^' , ')'] 
let a = head str 
if a `elem` mathSigns 
then str 
else if tail str /= [] 
     then getToNextSign $ tail str 
     else [] 

main = do 
putStrLn $ getToNextSign "(2sdwds+asd)+3" 

Это дает мне «ошибка разбора на входе =». Я также не уверен, как именно назвать это в основном, и мне действительно нужна функция putStrLn. Я не думаю, что мне это нужно, но я пробовал как 2874 разных способов написать это, и теперь я просто сдался и нуждался в помощи.

Answer 1

Haskell, будучи чувствительным к пробелу, должен иметь тело функции, отступающей от верхнего уровня. Прямое исправление исходного кода будет:

getToNextSign :: String -> String 
getToNextSign str = do 
    let mathSigns = ['+' , '-' , '*' , '/' , '^' , ')'] 
    let a = head str 
    if a `elem` mathSigns 
    then str 
    else if tail str /= [] 
     then getToNextSign $ tail str 
     else [] 

main = do 
    putStrLn $ getToNextSign "(2sdwds+asd)+3" 

Как было отмечено в комментариях вам не нужно делать запись здесь, так как вы не используете монады. Операторы let могут быть записаны в виде операторов.

getToNextSign :: String -> String 
getToNextSign str = 
    if a `elem` mathSigns 
    then str 
    else if tail str /= [] 
     then getToNextSign $ tail str 
     else [] 
    where 
    a = head str 
    mathSigns = ['+' , '-' , '*' , '/' , '^' , ')'] 

Answer 2

Помимо улучшения форматирования, предоставленного Стивеном Дилем, есть и другие улучшения, которые вы можете сделать. Как Карл указывает, вы можете заменить, если-то еще, если-то еще с охраной, так как:

getToNextSign :: String -> String 
getToNextSign str 
    | a `elem` mathSigns = str 
    | tail str /= []  = getToNextSign $ tail str 
    | otherwise   = [] 
    where 
    a = head str 
    mathSigns = ['+' , '-' , '*' , '/' , '^' , ')'] 

Когда вы на него, вы также можете заменить голову/хвост с сопоставления с образцом, как и в

getToNextSign :: String -> String 
getToNextSign (c:cs) 
    | c `elem` mathSigns = c:cs 
    | not (null cs)  = getToNextSign cs 
    | otherwise   = [] 
    where 
    mathSigns = ['+' , '-' , '*' , '/' , '^' , ')'] 

, и если вы собираетесь делать сопоставление с образцом, вы можете так же хорошо пройти его.

getToNextSign :: String -> String 
getToNextSign str = case str of 
    c:_ | c `elem` mathSigns -> str 
    c:[] -> [] 
    _:cs -> getToNextSign cs 
    where mathSigns = ['+' , '-' , '*' , '/' , '^' , ')'] 

и когда вы делаете это так, вы понимаете, что вы на самом деле не обрабатывается случай, когда getToNextSign получает пустой список в качестве аргумента, что, возможно, что вы хотите сделать.

Answer 3

Здесь представлена ​​более простая альтернатива вашей проблеме с использованием функций списка прелюдии, dropWhile и elem, который имеет тип sig (a -> Bool) -> [a] -> [a]. Он принимает функцию, которая удаляет элементы из списка, если условие, предоставляемое функцией, истинно.

Следовательно, ваша функция может быть переписана следующим образом.

let getNextSign x = dropWhile (not . `elem` "+-*/^)") x 

Старайтесь избегать явной рекурсии, когда это возможно, и надевайте более высокие функции порядка. И Prelude имеет множество функций манипулирования списком, которые пригодились все время.