main = putStrLn "Hello World"

Как только компилятор Haskell обнаружит вышеуказанный фрагмент кода, он быстро выдаст следующий вывод:

Hello World 

В этом руководстве мы приведем множество примеров, чтобы продемонстрировать всю мощь и простоту Haskell.

Haskell — Настройка среды

Мы настроили среду программирования на Haskell по адресу: https://www.tutorialspoint.com/compile_haskell_online.php

В этом онлайн-редакторе есть много вариантов, чтобы попрактиковаться в программировании на Haskell. Перейдите в раздел терминала на странице и введите «ghci» . Эта команда автоматически загружает компилятор Haskell и запускает Haskell онлайн. Вы получите следующий вывод после использования команды ghci .

sh-4.3$ ghci
GHCi,version7.8.4:http://www.haskell.org/ghc/:?forhelp
Loading package ghc-prim...linking...done.
Loading packageinteger gmp...linking... done.
Loading package base...linking...done.
Prelude>

Если вы по-прежнему хотите использовать Haskell в автономном режиме в локальной системе, вам необходимо загрузить доступную настройку Haskell с его официальной веб-страницы — https://www.haskell.org/downloads.

На рынке доступны три типа инсталляторов:

• Минимальный установщик — предоставляет GHC (компилятор Glasgow Haskell), CABAL (общая архитектура для создания приложений и библиотек) и инструменты стека.

• Установщик стека. В этом установщике GHC можно загрузить в кроссплатформенной цепочке управляемых сборов. Он установит ваше приложение глобально, так что он может обновлять свои инструменты API при необходимости. Он автоматически разрешает все зависимости, ориентированные на Haskell.

• Платформа Haskell — это лучший способ установить Haskell, потому что он установит всю платформу на ваш компьютер и в одну конкретную папку. Этот установщик не является дистрибутивом, как два вышеупомянутых установщика.

Минимальный установщик — предоставляет GHC (компилятор Glasgow Haskell), CABAL (общая архитектура для создания приложений и библиотек) и инструменты стека.

Установщик стека. В этом установщике GHC можно загрузить в кроссплатформенной цепочке управляемых сборов. Он установит ваше приложение глобально, так что он может обновлять свои инструменты API при необходимости. Он автоматически разрешает все зависимости, ориентированные на Haskell.

Платформа Haskell — это лучший способ установить Haskell, потому что он установит всю платформу на ваш компьютер и в одну конкретную папку. Этот установщик не является дистрибутивом, как два вышеупомянутых установщика.

Мы видели различные типы инсталляторов, доступных на рынке, теперь давайте посмотрим, как использовать эти инсталляторы на нашей машине. В этом руководстве мы собираемся использовать установщик платформы Haskell для установки компилятора Haskell в нашей системе.

Настройка среды в Windows

Чтобы настроить среду Haskell на своем компьютере с Windows, перейдите на их официальный веб-сайт https://www.haskell.org/platform/windows.html и загрузите установщик в соответствии с вашей настраиваемой архитектурой.

Проверьте архитектуру вашей системы, загрузите соответствующий установочный файл и запустите его. Он будет установлен как любое другое приложение Windows. Возможно, вам придется обновить конфигурацию CABAL вашей системы.

Настройка среды в MAC

Чтобы настроить среду Haskell в своей системе MAC, перейдите на их официальный веб-сайт https://www.haskell.org/platform/mac.html и загрузите установщик Mac.

Настройка среды в Linux

Установка Haskell в системе на основе Linux требует запуска некоторой команды, которая не так проста, как MAC и Windows. Да, это утомительно, но это надежно.

Вы можете следовать инструкциям ниже, чтобы установить Haskell в вашей системе Linux —

Шаг 1 — Чтобы настроить среду Haskell в вашей системе Linux, перейдите на официальный сайт https://www.haskell.org/platform/linux.html и выберите свой дистрибутив. Вы найдете следующий экран в вашем браузере.

Шаг 2 — Выберите ваш дистрибутив. В нашем случае мы используем Ubuntu. Выбрав эту опцию, вы получите следующую страницу на вашем экране с командой для установки Haskell в нашей локальной системе.

Шаг 3 — Откройте терминал, нажав Ctrl + Alt + T. Запустите команду «$ sudo apt-get install haskell-platform» и нажмите Enter. Он автоматически начнет загрузку Haskell в вашей системе после аутентификации с помощью пароля root. После установки вы получите подтверждающее сообщение.

Шаг 4 — Снова зайдите в свой терминал и выполните команду GHCI. Как только вы получите приглашение Prelude, вы готовы использовать Haskell в вашей локальной системе.

Чтобы выйти из пролога GHCI, вы можете использовать команду «: quit exit».

Haskell — Основные модели данных

Haskell — это чисто функциональный язык программирования, поэтому он намного более интерактивен и интеллектуален, чем другие языки программирования. В этой главе мы узнаем об основных моделях данных Haskell, которые фактически предопределены или каким-то образом интеллектуально декодированы в память компьютера.

В этом руководстве мы будем использовать онлайн-платформу Haskell, доступную на нашем веб-сайте ( https://www.tutorialspoint.com/codingground.htm ).

чисел

Haskell достаточно умен, чтобы декодировать некоторое число как число. Поэтому вам не нужно упоминать его тип внешне, как мы обычно делаем в случае других языков программирования. В соответствии с примером перейдите к командной строке прелюдии и просто запустите «2 + 2» и нажмите Enter.

sh-4.3$ ghci 
GHCi, version 7.6.3: http://www.haskell.org/ghc/  😕 for help 
Loading package ghc-prim ... linking ... done. 
Loading package integer-gmp ... linking ... done. 
Loading package base ... linking ... done. 
Prelude> 2+2

В результате вы получите следующий вывод.

4

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

Теперь давайте попробуем немного более сложные математические вычисления и посмотрим, даст ли наш интеллектуальный компилятор правильный вывод или нет. Попробуйте с «15+ (5 * 5) -40»

Prelude> 15+(5*5)-40 

Вышеупомянутое выражение выдает «0» согласно ожидаемому результату.

0

Персонажи

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

Давайте предоставим следующую строку в качестве входных данных и проверим ее вывод.

Prelude> :t "a" 

Это даст следующий результат —

"a" :: [Char] 

Помните, что вы используете (: t ) при подаче ввода. В приведенном выше примере (: t) должен включать конкретный тип, связанный с входными данными. Мы узнаем больше об этом типе в следующих главах.

Взгляните на следующий пример, где мы передаем недопустимый ввод в виде символа, что, в свою очередь, приводит к ошибке.

Prelude> :t a 
<interactive>:1:1: Not in scope: 'a'  

Prelude> a 
<interactive>:4:1: Not in scope: 'a' 

В сообщении об ошибке «<интерактивный>: 4: 1: за пределами области действия:« a »» компилятор Haskell предупреждает нас, что он не может распознать ваш ввод. Haskell — это тип языка, где все представлено числом.

Haskell следует традиционному стилю кодирования ASCII. Давайте посмотрим на следующий пример, чтобы понять больше —

Prelude> '\97' 
'a'  
Prelude> '\67' 
'C' 

Посмотрите, как ваши входные данные декодируются в формат ASCII.

строка

Строка — это не что иное, как набор символов. Нет определенного синтаксиса для использования строки, но Haskell следует общепринятому стилю представления строки в двойных кавычках.

Посмотрите на следующий пример, где мы передаем строку «Tutorialspoint.com».

Prelude> :t "tutorialspoint.com" 

Он выдаст следующий вывод на экран —

"tutorialspoint.com" :: [Char] 

Посмотрите, как вся строка была декодирована как массив только Char. Давайте перейдем к другому типу данных и его синтаксису. Как только мы начнем нашу практику, мы привыкнем ко всем типам данных и их использованию.

логический

Булев тип данных также довольно прост как другие типы данных. Посмотрите на следующий пример, где мы будем использовать различные логические операции с использованием некоторых логических входов, таких как «True» или «False».

Prelude> True && True 
True  
Prelude> True && False 
False   
Prelude> True || True 
True  
Prelude> True || False 
True

В приведенном выше примере нам не нужно упоминать, что «True» и «False» являются логическими значениями. Сам Haskell может декодировать его и выполнять соответствующие операции. Давайте изменим наши входные данные на «истина» или «ложь».

Prelude> true 

Это даст следующий результат —

<interactive>:9:1: Not in scope: 'true' 

В приведенном выше примере Haskell не может различить «true» и числовое значение, поэтому наш ввод «true» не является числом. Следовательно, компилятор Haskell выдает ошибку, утверждая, что наш ввод не является его областью действия.

Список и понимание списка

Как и другие типы данных, List также является очень полезным типом данных, используемым в Haskell. В соответствии с примером, [a, b, c] является списком символов, следовательно, по определению, List является набором данных того же типа данных, разделенных запятой.

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

Посмотрите на следующий пример, который показывает, как Haskell обрабатывает список.

Prelude> [1,2,3,4,5] 

Это даст следующий результат —

[1,2,3,4,5] 

Списки в Haskell по своей природе однородны, что означает, что они не позволят вам объявить список типов данных различного типа. Любой список типа [1,2,3,4,5, a, b, c, d, e, f] выдаст ошибку.

Prelude> [1,2,3,4,5,a,b,c,d,e,f] 

Этот код выдаст следующую ошибку —

<interactive>:17:12: Not in scope: 'a' 
<interactive>:17:14: Not in scope: 'b' 
<interactive>:17:16: Not in scope: 'c' 
<interactive>:17:18: Not in scope: 'd' 
<interactive>:17:20: Not in scope: 'e' 
<interactive>:17:22: Not in scope: 'f'

Понимание списка

Понимание списка — это процесс создания списка с использованием математического выражения. Посмотрите на следующий пример, где мы генерируем список, используя математическое выражение в формате [output | ассортимент, состояние.

Prelude> [x*2| x<-[1..10]] 
[2,4,6,8,10,12,14,16,18,20]  
Prelude> [x*2| x<-[1..5]] 
[2,4,6,8,10]  
Prelude> [x| x<-[1..5]] 
[1,2,3,4,5]

Этот метод создания одного списка с использованием математического выражения называется списком .

Кортеж

Haskell предоставляет еще один способ объявить несколько значений в одном типе данных. Это известно как Tuple . Кортеж можно рассматривать как список, однако существуют некоторые технические различия между кортежем и списком.

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

С другой стороны, List — это однородный тип данных, но Tuple по своей природе неоднороден, поскольку Tuple может содержать внутри себя данные другого типа.

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

Prelude> (1,1,'a') 

Это даст следующий результат —

(1,1,'a') 

В приведенном выше примере мы использовали один кортеж с двумя переменными числового типа и переменную типа char .

Haskell — Основные операторы

В этой главе мы узнаем о различных операторах, используемых в Haskell. Как и другие языки программирования, Haskell интеллектуально обрабатывает некоторые основные операции, такие как сложение, вычитание, умножение и т. Д. В следующих главах мы узнаем больше о различных операторах и их использовании.

В этой главе мы будем использовать различные операторы в Haskell, используя нашу онлайн-платформу ( https://www.tutorialspoint.com/codingground.htm ). Помните, что мы используем только целые числа, потому что мы узнаем больше о десятичных числах в следующих главах.

Оператор сложения

Как следует из названия, оператор сложения (+) используется для функции сложения. Следующий пример кода показывает, как вы можете добавить два целых числа в Haskell —

Live Demo

main = do 
   let var1 = 2 
   let var2 = 3 
   putStrLn "The addition of the two numbers is:" 
   print(var1 + var2) 

The addition of the two numbers is:
5

main = do 
   let var1 = 10 
   let var2 = 6 
   putStrLn "The Subtraction of the two numbers is:" 
   print(var1 - var2)

The Subtraction of the two numbers is:
4

main = do 
   let var1 = 2 
   let var2 = 3 
   putStrLn "The Multiplication of the Two Numbers is:" 
   print(var1 * var2) 

The Multiplication of the Two Numbers is:
6 

main = do 
   let var1 = 12 
   let var2 = 3 
   putStrLn "The Division of the Two Numbers is:" 
   print(var1/var2)

The Division of the Two Numbers is: 
4.0 

main :: IO() 
main = do 
   print [1..10]

[1,2,3,4,5,6,7,8,9,10] 

fType :: Int -> Int -> Int 
fType x y = x*x + y*y
main = print (fType 2 4) 

sh-4.3$ ghc -O2 --make *.hs -o main -threaded -rtsopts 
sh-4.3$ main
20

fType :: Int -> Int -> Int 
fType x y = x*x + y*y 
main = print (fType 212124454 44545454454554545445454544545)

main.hs:3:31: Warning:            
   Literal 44545454454554545445454544545 is out of the Int range -
   9223372036854775808..9223372036854775807 
Linking main ...

fType :: Integer -> Integer -> Integer 
fType x y = x*x + y*y 
main = print (fType 212124454 4454545445455454545445445454544545) 

sh-4.3$ main
1984297512562793395882644631364297686099210302577374055141

fType :: Float -> Float -> Float 
fType x y = x*x + y*y 
main = print (fType 2.5 3.8)

sh-4.3$ main
20.689999 

fType :: Double -> Double -> Double 
fType x y = x*x + y*y 
main = print (fType 2.56 3.81)

sh-4.3$ main 
21.0697

main = do  
   let x = True 
   
   if x == False 
      then putStrLn "X matches with Bool Type" 
   else putStrLn "X is not a Bool Type" 

sh-4.3$ main
X is not a Bool Type 

fType :: Char-> Char 
fType x = 'K' 
main = do  
   let x = 'v' 
   print (fType x) 

sh-4.3$ main 
'K'

main = do 
   if 8 /= 8 
      then putStrLn "The values are Equal" 
   else putStrLn "The values are not Equal"

sh-4.3$ main 
The values are not Equal 

main = print (4 <= 2) 

sh-4.3$ main 
False

main = print (show [1..10]) 

sh-4.3$ main 
"[1,2,3,4,5,6,7,8,9,10]" 

main = print (readInt "12") 
readInt :: String -> Int 
readInt = read 

sh-4.3$ main 
12

main = print (succ 12) 

sh-4.3$ main
13

main = do 
   print (maxBound :: Int) 
   print (minBound :: Int) 

sh-4.3$ main
9223372036854775807
-9223372036854775808

main = do 
   print(2 :: Int)  
   print(2 :: Float) 

sh-4.3$ main
2
2.0

data Area = Circle Float Float Float  
surface :: Area -> Float   
surface (Circle _ _ r) = pi * r ^ 2   
main = print (surface $ Circle 10 20 10 ) 

sh-4.3$ main
314.15927

add :: Integer -> Integer -> Integer   --function declaration 
add x y =  x + y                       --function definition 

main = do 
   putStrLn "The addition of the two numbers is:"  
   print(add 2 5)    --calling a function 

The addition of the two numbers is:
7

fact :: Int -> Int 
fact 0 = 1 
fact n = n * fact ( n - 1 ) 

main = do 
   putStrLn "The factorial of 5 is:" 
   print (fact 5)

The factorial of 5 is:
120

fact :: Integer -> Integer 
fact n | n == 0 = 1 
       | n /= 0 = n * fact (n-1) 
main = do 
   putStrLn "The factorial of 5 is:"  
   print (fact 5) 

The factorial of 5 is:
120

roots :: (Float, Float, Float) -> (Float, Float)  
roots (a,b,c) = (x1, x2) where 
   x1 = e + sqrt d / (2 * a) 
   x2 = e - sqrt d / (2 * a) 
   d = b * b - 4 * a * c  
   e = - b / (2 * a)  
main = do 
   putStrLn "The roots of our Polynomial equation are:" 
   print (roots(1,-8,6))

The roots of our Polynomial equation are:
(7.1622777,0.8377223)

fact :: Int -> Int 
fact 0 = 1 
fact n = n * fact ( n - 1 ) 

main = do 
   putStrLn "The factorial of 5 is:" 
   print (fact 5) 

The factorial of 5 is:
120

import Data.Char  
import Prelude hiding (map) 

map :: (a -> b) -> [a] -> [b] 
map _ [] = [] 
map func (x : abc) = func x : map func abc  
main = print $ map toUpper "tutorialspoint.com" 

sh-4.3$ ghc -O2 --make *.hs -o main -threaded -rtsopts
sh-4.3$ main
"TUTORIALSPOINT.COM" 

main = do 
   putStrLn "The successor of 4 is:"  
   print ((\x -> x + 1) 4)

sh-4.3$ main
The successor of 4 is:
5

 main = do 
    пусть х = [1..10]   
    putStrLn "Наш список:"  
    печать (х) 
    putStrLn "Первый элемент списка:" 
    печать (голова х)

 Наш список: 
 [1,2,3,4,5,6,7,8,9,10]
 Первый элемент списка:
 1

 main = do 
    пусть х = [1..10]   
    putStrLn "Наш список:"  
    печать (х) 
    putStrLn "Хвост нашего списка:" 
    печать (хвост х) 

 Наш список:
 [1,2,3,4,5,6,7,8,9,10]
 Хвост нашего списка:
 [2,3,4,5,6,7,8,9,10]

 main = do 
    пусть х = [1..10]   
    putStrLn "Наш список:"  
    печать (х) 
    putStrLn "Последний элемент нашего списка:" 
    печать (последний х)

 Наш список:
 [1,2,3,4,5,6,7,8,9,10]
 Последний элемент нашего списка:
 10

 main = do 
    пусть х = [1..10]   
    putStrLn "Наш список:"  
    печать (х) 
    putStrLn "Наш список без последней записи:"  
    печать (init x) 

 Наш список:
 [1,2,3,4,5,6,7,8,9,10]
 Наш список без последней записи:
 [1,2,3,4,5,6,7,8,9]

 main = do 
    пусть х = [1..10]   
    putStrLn "Наш список:"  
    печать (х) 
    putStrLn "Наш список пуст?"  
    печать (ноль х)

 Наш список:
 [1,2,3,4,5,6,7,8,9,10]
 Наш список пуст?
 Ложь

 main = do 
    пусть х = [1..10]  
    putStrLn "Наш список:" 
    печать (х) 
    putStrLn "Список в обратном порядке:" 
    печать (обратный х)

 Наш список:
 [1,2,3,4,5,6,7,8,9,10]
 Список в обратном порядке:
 [10,9,8,7,6,5,4,3,2,1]

 main = do 
    пусть х = [1..10]   
    putStrLn "Наш список:" 
    печать (х) 
    putStrLn "Длина этого списка:" 
    печать (длина х)

 Наш список:
 [1,2,3,4,5,6,7,8,9,10]
 Длина этого списка:
 10

 main = print (взять 5 ([1 .. 10])) 

 [1,2,3,4,5]

 main = print (drop 5 ([1 .. 10])) 

 [6,7,8,9,10]

 main = do 
    пусть х = [1,45,565,1245,02,2]   
    putStrLn "Максимальное значение элемента списка:"  
    печать (максимум х)

 Максимальное значение элемента списка:
 1245

 main = do 
    пусть х = [1,45,565,1245,02,2]   
    putStrLn "Элемент минимального значения в списке:"  
    печать (минимум х)

 Элемент минимального значения в списке:
 1

 main = do 
    пусть х = [1..5] 
    putStrLn "Наш список:" 
    печать (х) 
    putStrLn "Суммирование элементов списка:" 
    печать (сумма х)

 Наш список:
 [1,2,3,4,5]
 Суммирование элементов списка:
 15

 main = do 
    пусть х = [1..5] 
    putStrLn "Наш список:" 
    печать (х) 
    putStrLn "Умножение элементов списка:" 
    печать (продукт х) 

 Наш список:
 [1,2,3,4,5]
 Умножение элементов списка: 
 120

 main = do 
    пусть х = [1,45,155,1785] 
    putStrLn "Наш список:" 
    печать (х) 
    putStrLn "Содержит ли он 786?" 
    печать (элемент 786 (х))

 Наш список:
 [1,45,155,1785]
 Содержит ли он 786?
 Ложь

eveno :: Int -> Bool 
noto  :: Bool -> String 

eveno x = if x `rem` 2 == 0 
   then True 
else False 
noto x = if x == True 
   then "This is an even Number" 
else "This is an ODD number" 

main = do 
   putStrLn "Example of Haskell Function composition" 
   print ((noto.eveno)(16))

Example of Haskell Function composition                
"This is an even Number"

import Data.List  

main = do  
   putStrLn("Different methods of List Module") 
   print(intersperse '.' "Tutorialspoint.com") 
   print(intercalate " " ["Lets","Start","with","Haskell"]) 
   print(splitAt 7 "HaskellTutorial") 
   print (sort [8,5,3,2,1,6,4,2])

Different methods of List Module
"T.u.t.o.r.i.a.l.s.p.o.i.n.t...c.o.m"
"Lets Start with Haskell"
("Haskell","Tutorial")
[1,2,2,3,4,5,6,8]

import Data.Char 

main = do  
   putStrLn("Different methods of Char Module") 
   print(toUpper 'a') 
   print(words "Let us study tonight") 
   print(toLower 'A')

Different methods of Char Module
'A'
["Let","us","study","tonight"]
'a'

import Data.Map (Map) 
import qualified Data.Map as Map  --required for GHCI  

myMap :: Integer -> Map Integer [Integer] 
myMap n = Map.fromList (map makePair [1..n]) 
   where makePair x = (x, [x])  

main = print(myMap 3)

fromList [(1,[1]),(2,[2]),(3,[3])] 

import qualified Data.Set as Set   

text1 = "Hey buddy"   
text2 = "This tutorial is for Haskell"   

main = do  
   let set1 = Set.fromList text1   
       set2 = Set.fromList text2 
   print(set1) 
   print(set2)    

fromList " Hbdeuy"
fromList " HTaefhiklorstu"

module Custom ( 
   showEven, 
   showBoolean 
) where 

showEven:: Int-> Bool 
showEven x = do 

if x 'rem' 2 == 0 
   then True 
else False 
showBoolean :: Bool->Int 
showBoolean c = do 

if c == True 
   then 1 
else 0 

import Custom 

main = do 
   print(showEven 4) 
   print(showBoolean True) 

True
1

main = do  
   let file = "abc.txt" 
   contents <- readFile file 
   putStrLn contents   

Welcome to Tutorialspoint
Here, you will get the best resource to learn Haskell.

let file = "abc.txt" 
writeFile file "I am just experimenting here." 
readFile file 

I am just experimenting here.

import Control.Exception 

main = do 
   result <- try (evaluate (5 `div` 0)) :: IO (Either SomeException Int) 
   case result of 
      Left ex   -> putStrLn $ "Caught exception: " ++ show ex 
      Right val -> putStrLn $ "The answer was: " ++ show val 

Caught exception: divide by zero 

class Functor f where 
   fmap :: (a -> b) -> f a -> f b 

main = do  
   print(map (subtract 1) [2,4,8,16])      
   print(fmap (subtract 1) [2,4,8,16])   

[1,3,7,15]
[1,3,7,15]

main = do 
   print (fmap  (+7)(Just 10)) 
   print (fmap  (+7) Nothing)

Just 17
Nothing

class (Functor f) => Applicative f where   
   pure :: a -> f a   
   (<*>) :: f (a -> b) -> f a -> f b   

import Control.Applicative 

f1:: Int -> Int -> Int 
f1 x y = 2*x+y  
main = do  
   print(show $ f1 <$> (Just 1) <*> (Just 2) ) 

"Just 4"

class Monoid m where  
   mempty :: m 
   mappend :: m -> m -> m  
   mconcat :: [m] -> m 
   mconcat = foldr mappend mempty 

multi:: Int->Int 
multi x = x * 1 
add :: Int->Int 
add x = x + 0 

main = do  
   print(multi 9)  
   print (add 7)

9
7

class Monad m where  
   return :: a -> m a 
   (>>=) :: m a -> (a -> m b) -> m b 
   (>>) :: m a -> m b -> m b 
   x >> y = x >>= \_ -> y 
   fail :: String -> m a  
   fail msg = error msg 

main = do
   print([1..10] >>= (\x -> if odd x then [x*2] else []))

[2,6,10,14,18]

data List a = Empty | Cons a (List a) deriving (Show, Read, Eq, Ord)
type Zipper_List a = ([a],[a])    

go_Forward :: Zipper_List a -> Zipper_List a   
go_Forward (x:xs, bs) = (xs, x:bs)   
   
go_Back :: Zipper_List a -> Zipper_List a   
go_Back (xs, b:bs) = (b:xs, bs)    

main = do 
   let list_Ex = [1,2,3,4] 
   print(go_Forward (list_Ex,[]))       
   print(go_Back([4],[3,2,1])) 

([2,3,4],[1]) 
([3,4],[2,1])