Tekst źródłowy strony Programowanie w systemie UNIX/Haskell

[[File:Haskell-Logo-Variation.png|right]]


       '''"A language that doesn't affect the way you think about programming, is not worth knowing. "'''<ref>[http://www.cs.yale.edu/quotes.html EPIGRAMS IN PROGRAMMING]</ref>

[[Haskell]] zmieni twój sposób myślenia o programowaniu (:-))

Wykorzystuje [[W:Teoria kategorii|teorię kategorii]].<ref>[[w:Teoria kategorii|Teoria kategorii]]</ref>


   Eugenia Chang's characterization of category theory:  category theory is the mathematics of mathematics. whatever mathematics does for the world category Theory does for mathematics







=Cechy Haskella =
* jest to język czysto funkcyjny:<ref>[http://wazniak.mimuw.edu.pl/index.php?title=Paradygmaty_programowania/Wyk%C5%82ad_10:_Programowanie_funkcyjne_w_Haskellu_I| Paradygmaty_programowania : Małgorzata Moczurad i Włodzimierz Moczurad — Uniwersytet Jagielloński ]</ref>
** nie ma zmiennych w znaczeniu pojemników na wartości jak np. w [[C]], są stałe (niewiadome jak w matematyce)
** nie ma efektów ubocznych
* lenistwo: obliczenia są wykonywane w momencie kiedy ich rezultat jest potrzebny, nie wcześniej. W efekcie możesz definiować nieskończone struktury danych, pod warunkiem, że nie używasz ich w całości. 
* nie ma pętli (używa rekurencji)<ref>[http://gnosis.cx/publish/programming/Haskell.pdf  David Mertz - Haskell tutorial]</ref>
* funkcje wyższego rzędu - funkcje mogą być argumentami innych funkcji. Umożliwia to składanie przekształceń.
* polimorfizm
* klasy typów
* monady

==Składnia==
* Pointfree Style<ref>[https://wiki.haskell.org/Pointfree Pointfree style]</ref>
* Pointfull style
* non-layout syntax with curly braces and semicolons <ref>[https://stackoverflow.com/questions/2846050/how-to-define-a-function-in-ghci-across-multiple-lines stackoverflow question : how-to-define-a-function-in-ghci-across-multiple-lines]</ref>
* do block

=Instalacja=

Potrzebujemy:
* kompilator/interpreter (GHC)
* menadżer pakietów (cabal)
* edytor (np. Gedit ma podświetlanie składni Haskella)

Metody:
* z użyciem standardowych instalatorów  (stabilna, ale zwykle nie najnowsza wersja), np.: 
** Centrum Oprogramowania Ubuntu
** Menadżer Pakietów Synaptic
* ręczna najnowszej wersji <ref>[http://gracjanpolak.wordpress.com/2010/05/17/instalacja-ghc-w-wersji-minimalnej/ Gracjan Polak - Instalacja GHC w wersji minimalnej]</ref>

= Przykłady=

==Funkcje==

== definicje==
* w kodzie
** 
* w osobnym pliku

  let f :: a -> a ; f x = x -- GHCI , one line, signature
  let { fact 0 = 1 ; fact n = n * fact (n-1) } -- use braces with semicolons separating the definitions



<syntaxhighlight lang=haskell>
-- https://pl.wikibooks.org/w/index.php?title=Programowanie_w_systemie_UNIX/Haskell&action=edit&section=5
> :set +m
> let a 0 = 0
|     a x = 1 + b x
|     b x = 2 + a (x -  1)
> a 1
3
</syntaxhighlight>




===Kwadrat liczby===
Przykład<ref>[http://gnosis.cx/publish/programming/Haskell.pdf Podobne Beginning with the Haskell Programming Language by gnosis]</ref>
 

{|width="100%" cellspacing="0" cellpadding="15" valign="top" style="margin:0.8em 0; border: 1px solid SlateBlue; background:#F7F7FF"


|valign="top" style="border-right:1px dashed SlateBlue"|

<syntaxhighlight lang=haskell>
-- Haskell
square :: Int -> Int 
square n = n*n 
</syntaxhighlight>
|valign="top" style="border-right:1px dashed SlateBlue"|
<syntaxhighlight lang=c>
// c
int square(int n) {
return n*n; }

</syntaxhighlight>


|}
===Złożenie (superpozycja) funkcji ===
Złożenie (superpozycja) funkcji ( ang. function composition) za pomocą:
* operatora . ( ang. dot operator) 
* stylu pointfree

<syntaxhighlight lang=haskell>
-- the '.' operator is used to compose functions
 
-- result of sort is pipelined to reverse
desort = (reverse . sort)
 
-- the result is a descending sort
countdown = desort [2,8,7,10,1,9,5,3,4,6]
</syntaxhighlight>

Porównanie: 


{|width="100%" cellspacing="0" cellpadding="15" valign="top" style="margin:0.8em 0; border: 1px solid SlateBlue; background:#F7F7FF"

|valign="top" style="border-right:1px dashed SlateBlue"|
<math>f \circ\ g (x)</math>


|valign="top" style="border-right:1px dashed SlateBlue"|

<syntaxhighlight lang=haskell>
-- Haskell
f . g -- pointfree style
f . g  x -- pointfull style
f (g  x) --
( f . g ) (x) --
</syntaxhighlight>

|valign="top" style="border-right:1px dashed SlateBlue"|
<syntaxhighlight lang=c>
// c
f(g(x))
</syntaxhighlight>

|}
===pętle===
* Control.Monad.Loops (whileM_)<ref>[http://conscientiousprogrammer.com/blog/2015/12/11/24-days-of-hackage-2015-day-11-monad-loops-avoiding-writing-recursive-functions-by-refactoring/ avoiding writing recursive functions by refactoring by  Franklin Chen]</ref>
* go 
====go====

Funkcja go<ref>[https://stackoverflow.com/questions/5844653/haskell-why-the-convention-to-name-a-helper-function-go stackoverflow question: haskell-why-the-convention-to-name-a-helper-function-go]</ref>

<syntaxhighlight lang=haskell>
-- https://stackoverflow.com/questions/5926033/haskell-efficient-equivalent-of-for-loop
import System.IO

loop :: Int -> IO ()
loop n = go n
  where
    go n | n <= 0 = return ()
    go n          = go (n-1)

main = loop 1000000
</syntaxhighlight>



<syntaxhighlight lang=haskell>
-- https://gist.github.com/niorad/45187d9eb76c585e573e
divideBy x y = go x y 0
  where go a b count
        | a < b = (count, a)
        | otherwise = go (a - b) b (count + 1)
</syntaxhighlight>

Zmienna count jest pomocniczym licznikiem

==Listy==

Listy skończone <ref>[http://www.mimuw.edu.pl/~zawlocki/haskell/Programowanie_w_Haskellu.html Programowanie w Haskellu - Artur Zawłocki ]</ref>

 sum [1..10]

 product [1..10]

Listy nieskończone (przykład [[Haskell#Leniwe_warto.C5.9Bciowanie|leniwego wartościowania]]): <ref>[http://www.deltami.edu.pl/temat/informatyka/2013/06/29/strumienie.pdf "Strumienie, czyli pochwała lenistwa" artykuł Marcina Benke, Delta, lipiec 2013 ]</ref>

 [1,3..]
 [1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,{Interrupted!}

 take 20 [1,3..]
 [1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39]



===cycle===
Cycle 
<syntaxhighlight lang=haskell>
  ghci> take 10 (cycle [1,2,3])   -- weź 10 pierwszych elementów z listy cyklicznej utworzonej przez powtarzanie elementów listy [1,2,3]
  [1,2,3,1,2,3,1,2,3,1]  
  ghci> take 12 (cycle "LOL ")  
  "LOL LOL LOL "   
</syntaxhighlight>

==Klasy==

==Monady==
Poradniki:
* http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html

==Wejście i wyjście ==

Wczytywanie argumentów:
 -- http://zvon.org/other/haskell/Outputsystem/getArgs_f.html
 -- save it as a file a.hs
 -- runhaskell a.hs 1 33 aaaa
 import System
 main = do 
 x <- getArgs
 print x

Wczytywanie pliku tekstowego, którego nazwa jest podana jako argument programu:

 -- save it as a file f.hs
 -- runhaskell f.hs gruff.txt
 import System 
 main = do 
 args <- System.getArgs
 let fileName = head args
 print fileName
 -- read text file
 text <- readFile fileName
 --  
 putStrLn text

=Pliki z kodem w Haskellu=
==hs==

Pliki z rozszerzeniem ''hs'' zawierają kod Haskella. Może to być:<ref>[https://stackoverflow.com/questions/16997950/whats-the-difference-between-module-package-and-library-in-haskell#comment77851064_16997950 stackoverflow question: whats-the-difference-between-module-package-and-library-in-haskell]</ref>
* funkcja
* moduł
* pakiet 
* program


===Funkcje===

Definicję funkcji ''mojafunkcja'' '''zapisz do pliku''' ''mojafunkcja.hs''
W trybie interaktywnym ( ghci) '''wczytujesz''' funkcję za pomocą komendy:
 :l mojafunkcja 
albo 
 :r -- reload current script

===Moduł===

Moduł zawiera kilka funkcji.
Każdy moduł to jeden plik. 
Nazwa modułu odpowiada nazwie pliku, z wyjątkiem modułu głównego. 

Standardowe moduły:
* Prelude<ref>[http://www.haskell.org/onlinereport/standard-prelude.html Moduł Prelude]</ref>


Sprawdzmy listę funkcji w module : 

  :browse nazwa_modułu

===Pakiet===

Pakiet '''zawsze zawiera''': <ref>[http://www.haskell.org/cabal/proposal/x138.html System pakietów Haskella]</ref>
* jeden lub kilka modułów
'''Może zawierać''':
*  kod w języku C
* pliki nagłówkowe
* dokumentację
* testy dla zawartych modułów
* dodatkowe narzędzia

Polecenie:

 ghc-pkg list

pokazuje '''listę zainstalowanych pakietów''' <ref>[http://www.haskell.org/ghc/docs/7.0.3/html/users_guide/packages.html Pakiety Haslkella]</ref>

Możemy poprosić o '''opis''' jednego z zainstalowanych modułów, np ''time'':

 ghc-pkg describe time

====Cabal====

Cabal jest to program ułatwiający pracę z pakietami.

Pakiety cabala mogą występować w 3 postaciach:
* kodu źródłowego (skompresowanego w plikach tar-ball, zip)
* plikach binarnych
* specjalnych postaciach: RPM, pakiety Debiana, windows <ref>[http://www.haskell.org/cabal/proposal/x138.html Pakiety w Haskellu]</ref>

Przykład : 

  ghc-pkg Vector        -- sprawdzamy czy mamy moduł vector
  cabal update          -- uaktualniamy cabal
  cabal install Vector  -- instalujemy moduł vector

===Program===

Kompletny program w Haskellu zawiera jeden lub więcej modułów (w tym główny moduł Main) skompilowanych z użyciem pakietów (w tym pakiet Prelude)

==== Pierwszy program ====
Najprostszy program składa się z:<ref>[http://www.haskell.org/ghc/docs/7.0.3/html/users_guide/packages.html Pakiety w Haskellu ]</ref><ref>[https://stackoverflow.com/questions/13392134/in-need-of-the-most-simple-haskell-program stackoverflow question: iin-need-of-the-most-simple-haskell-program]</ref>
* jednego głównego pakietu (main)
* jednego głównego modułu (Main)
* jednej głównej funkcji (main). <ref>[[wikibooks:Haskell/YAHT/Language_basics#Source_Code_Files |Pliki z kodem źródłowym w ang podręczniku]]</ref><ref>[[wikibooks:wikibooks:Haskell/Applications|Aplikacja Haskella w ang wikibooks]]</ref>

 -- moduł główny Main
 module Main
   (main) -- nazwa eksportowanej funkcji
    where
 -- definicja funkcji main
 main = putStrLn "Hello world"

Program zapisujemy do pliku, np. <code>w.hs</code> 

Jak widać nazwa pliku zawierającego moduł główny nie musi być taka sama jak nazwa modułu.


Program kompilujemy:
 ghc -o w w.hs

i uruchomiamy:
 ./w

[[Plik:PascalungeradeDreieckeGleichseitig.svg|mały|prawo|Trójkąt sierpińskiego]]
Bardziej skomplikowany przykład, trójkąt Sierpińskiego: 

<syntaxhighlight lang=haskell>
-- http://dev.stephendiehl.com/hask/#diagrams
import Diagrams.Prelude
import Diagrams.Backend.SVG.CmdLine

sierpinski :: Int -> Diagram SVG
sierpinski 1 = eqTriangle 1
sierpinski n =
      s
     ===
  (s ||| s) # centerX
  where
    s = sierpinski (n - 1)

example :: Diagram SVG
example = sierpinski 5 # fc black

main :: IO ()
main = defaultMain example
</syntaxhighlight>

Uruchamiamy: 

   runhaskell diagram1.hs -w 256 -h 256 -o diagram1.svg

====Pierwszy projekt ====

Projekt <ref>[http://www.haskell.org/haskellwiki/How_to_write_a_Haskell_program#Build_system Struktura pierwszego projeltu w Haskellu]</ref>

==hsl==

Pliki z rozszerzeniem hsl zawierają kod w stylu programowania piśmiennego (ang. literate programming)  <ref>[[w:Literate programming | Programowanie piśmienne w wikipedii]]</ref>

=Jak pracować w Haskellu =
* tryb interaktywny (ghci)
* kompilacja kodu (ghc)
* z użyciem skryptu runhaskell

== runhaskell==

Z użyciem skryptu BASHA: 
 runhaskell m.hs

== ghc ==

W trybie kompilacji najpierw kompilujemy:
 ghc -o m  m.hs

potem uruchamiamy wykonywalny plik: 
 ./m

Sprawdzamy wersję i zainstalowane moduły: 

  ghc -v

przykładowy wynik : 

<pre>
Glasgow Haskell Compiler, Version 7.10.3, stage 2 booted by GHC version 7.10.3
Using binary package database: /usr/lib/ghc/package.conf.d/package.cache
wired-in package ghc-prim mapped to ghc-prim-0.4.0.0-6cdc86811872333585fa98756aa7c51e
wired-in package integer-gmp mapped to integer-gmp-1.0.0.0-3c8c40657a9870f5c33be17496806d8d
wired-in package base mapped to base-4.8.2.0-0d6d1084fbc041e1cded9228e80e264d
wired-in package rts mapped to builtin_rts
wired-in package template-haskell mapped to template-haskell-2.10.0.0-3c4cb52230f347282af9b2817f013181
wired-in package ghc mapped to ghc-7.10.3-624693c6aa854116c707bc7b4d0d7cb6
wired-in package dph-seq not found.
wired-in package dph-par not found.
Hsc static flags: 
*** Deleting temp files:
Deleting: 
*** Deleting temp dirs:
Deleting: 
ghc: no input files
Usage: For basic information, try the `--help' option.
</pre>


Dostępne moduły : 

  ghc-pkg list

przykładowy wynik : 

<pre>
/usr/lib/ghc/package.conf.d
   Cabal-1.22.5.0
   array-0.5.1.0
   base-4.8.2.0
   bin-package-db-0.0.0.0
   binary-0.7.5.0
   bytestring-0.10.6.0
   containers-0.5.6.2
   deepseq-1.4.1.1
   directory-1.2.2.0
   filepath-1.4.0.0
   ghc-7.10.3
   ghc-prim-0.4.0.0
   haskeline-0.7.2.1
   hoopl-3.10.0.2
   hpc-0.6.0.2
   integer-gmp-1.0.0.0
   pretty-1.1.2.0
   process-1.2.3.0
   rts-1.0
   template-haskell-2.10.0.0
   terminfo-0.4.0.1
   time-1.5.0.1
   transformers-0.4.2.0
   unix-2.7.1.0
   xhtml-3000.2.1
</pre>

==ghci==
W trybie interaktywnym: 
 ghci m.hs
 
potem uruchamiamy funkcję: 
 main


Ładowanie (wczytanie) modułów:

 :load nazwa

Po wczytaniu modułu trzeba go uaktywnić:
 :module nazwa

np.:

 :m + Fractal.RUFF.Mandelbrot.Address
uaktywnia moduł Address z pakietu RUFF (''m'' jest skrótem od ''module'' <ref>[http://www.haskell.org/ghc/docs/latest/html/users_guide/interactive-evaluation.html#ghci-scope Using GHCi doc]</ref>)


  :quit
aby wyjść

Tryb edycji wieloliniowej (ang.  multiline-input mode )

  :set +m

Lista modułów zdefiniowanych przez użytkownika:<ref>[https://stackoverflow.com/questions/10272094/haskell-display-get-list-of-all-user-defined-functions stackoverflow question: haskell-display-get-list-of-all-user-defined-functions]</ref>

 :show modules

Lista funkcji w module 

 :browse ModuleName

Znak zachęty (monit,  ang. prompt): Monit wskazuje, nad którym modułem (modułami) trwają prace:
* znak zachęty zmienił się na *ghci>, aby wskazać, że bieżącym kontekstem dla wyrażeń wpisywanych w znaku zachęty jest moduł główny, który właśnie załadowaliśmy
* Prelude is the only module you have without any imports

=Problemy=

==cabal: unrecognised command: sandbox (try --help)==

Może wersja cabala jest za stara?<ref>[http://stackoverflow.com/questions/23897816/cabal-run-gives-unrecognised-command-run Stackoverflow question: cabal-run-gives-unrecognised-command-run]</ref>
Sprawdzamy: 

 cabal -V

przykładowy wynik: 

 cabal-install version 1.16.0.2
 using version 1.16.0 of the Cabal library 

upgrade: 

 cabal install cabal-install


oraz: 

 export PATH="$HOME/.cabal/bin:${PATH}"

=Pomoc=
==info==
  :info name

przykład:

<syntaxhighlight lang=haskell>
:info ($)
($) :: (a -> b) -> a -> b 	-- Defined in ‘GHC.Base’
infixr 0 $

</syntaxhighlight>


== path==

  :show paths

zmień ścieżkę: 

  :cd path

==typ==


 :t nazwa

==hlint==

  hlint a.hs

=Zobacz również=
* [https://wiki.haskell.org/How_to_read_Haskell How to read Haskell code ?]
* [http://ics.p.lodz.pl/~stolarek/_media/pl:research:stolarek_understanding_basic_haskell_error_messages.pdf Understanding Basic Haskell Error Messages by Jan Stolarek]
* [http://www.ia.pw.edu.pl/~mszlenk/ Marcin Szlenk - programowanie w języku Haskell i funkcyjne]
* [http://www.slideshare.net/guestc1e6127/haskell-presentation-794922 Haskell - Tomek „QsoRiX” Rydzynski]
* [http://wazniak.mimuw.edu.pl/index.php?title=Programowanie_funkcyjne Programowanie funkcyjne - Marcin Kubica]
* [http://cheatsheet.codeslower.com/CheatSheet.pdf Haskell Cheat Sheet ]
* [http://www.imada.sdu.dk/~rolf/Edu/DM22/F06/haskell-operatorer.pdf haskell operatorer]
* [https://gist.github.com/mikehaertl/3258427 Learn you a Haskell - In a nutshell by Michael Härtl]
* [https://stackoverflow.com/questions/1012573/getting-started-with-haskell?rq=1 stackoverflow question: getting-started-with-haskell]
* wyszukiwarki:
** [http://hayoo.fh-wedel.de/ Hayoo! - Haskell API Search]
** [https://www.haskell.org/hoogle/ Hoogle is a Haskell API search engin]

{{Przypisy}}
{{BrClear}} <noinclude>{{Wolumin}}</noinclude>