Haskell - Revision history

Savoundg: /* Example of Functors */

2016-11-03T17:50:47Z

Example of Functors

Savoundg at 08:37, 3 November 2016

2016-11-03T08:37:09Z

← Older revision		Revision as of 08:37, 3 November 2016
Line 391:		Line 391:
	\|-		\|-
	\|Monoid		\|Monoid
	\|		\|mempty, mappend, mconcat
	\|		\|(-> r)
	\|The ''Monoid'' Laws:		\|The ''Monoid'' Laws:
	* Identity		* Identity
Line 438:		Line 438:
	instance Functor ((->) r) where		instance Functor ((->) r) where
	fmap = (.)		fmap = (.)
			</syntaxhighlight>

			==== Example of Applicative Functors ====

			==== Example of Monads ====
			<syntaxhighlight lang="haskell">
			instance Monad ((->) r) where
			return x = \_ -> x
			h >>= f = \w -> f (h w) w
	</syntaxhighlight>		</syntaxhighlight>

Savoundg: Type classes

2016-11-02T12:45:20Z

Type classes

← Older revision		Revision as of 12:45, 2 November 2016
Line 288:		Line 288:
	A kind is the type of a type constructor.		A kind is the type of a type constructor.

	=== ~~Typeclass~~<ref>http://learnyouahaskell.com/types-and-typeclasses#typeclasses-101</ref> ===		=== Type classes<ref>http://learnyouahaskell.com/types-and-typeclasses#typeclasses-101</ref> ===
	~~instance declaration, method~~
	{\| class="wikitable"		{\| class="wikitable"
	!Typeclass		!Typeclass
Line 370:		Line 370:
	\|-		\|-
	\|Functor		\|Functor
	\|		\|fmap
	\|[], Maybe, Either a, IO, (->) r		\|[], Maybe, Either a, IO, (->) r
	\|		\|The ''Functo''r Laws:
			* Identity
			* Preserve composition
	\|'''f''' is a type constructor that take one parameter.<syntaxhighlight lang="haskell">		\|'''f''' is a type constructor that take one parameter.<syntaxhighlight lang="haskell">
	class Functor f where		class Functor f where
Line 379:		Line 381:
	\|-		\|-
	\|Applicative		\|Applicative
	\|		\|pure, <*>
	\|		\|[], Maybe, IO, (-> r)
	\|		\|
	\|<syntaxhighlight lang="haskell">		\|<syntaxhighlight lang="haskell">
Line 387:		Line 389:
	(<*>) :: f (a -> b) -> f a -> f b		(<*>) :: f (a -> b) -> f a -> f b
	</syntaxhighlight>		</syntaxhighlight>
			\|-
			\|Monoid
			\|
			\|
			\|The ''Monoid'' Laws:
			* Identity
			* Associativity
			\|<syntaxhighlight lang="haskell">
			class Monoid m where
			mempty :: m
			mappend :: m -> m -> m
			mconcat :: [m] -> m
			mconcat = foldr mappend mempty
			</syntaxhighlight>
			\|-
			\|Monad
			\|
			\|
			\|
			\|
	\|}		\|}
	To make the type ''Character'' instance of the typeclass ''Eq:''<syntaxhighlight lang="haskell">		To make the type ''Character'' instance of the typeclass ''Eq:''<syntaxhighlight lang="haskell">
Line 393:		Line 415:
	</syntaxhighlight>		</syntaxhighlight>

	==== Functors ====		==== Example of Functors ====
	<syntaxhighlight lang="haskell">		<syntaxhighlight lang="haskell">
	instance Functor [] where		instance Functor [] where
Line 423:		Line 445:
	The '''then''' operator (>>) is used to chain monadic expression such as I/O action.		The '''then''' operator (>>) is used to chain monadic expression such as I/O action.

	The '''bind''' operator (>>=) passes the value of an action to another action.		The '''bind''' operator (>>=) passes the value of an action (monadic value) to another action (monad).

	==== do notation/block<ref>https://en.wikibooks.org/wiki/Haskell/do_notation</ref> ====		==== do notation/block<ref>https://en.wikibooks.org/wiki/Haskell/do_notation</ref> ====

Savoundg: /* Resources */

2016-10-16T08:31:05Z

Resources

← Older revision		Revision as of 08:31, 16 October 2016
Line 736:		Line 736:
	== Resources ==		== Resources ==
	{\| class="wikitable"		{\| class="wikitable"
	!
	!
	\|-		\|-
	\|Learn You a Haskell for Great Good!		\|Learn You a Haskell for Great Good!

Savoundg at 09:19, 2 October 2016

2016-10-02T09:19:01Z

← Older revision		Revision as of 09:19, 2 October 2016
Line 197:		Line 197:
	\|-		\|-
	\|Double		\|Double
	\|		\|Use it instead of Float.
	\|-		\|-
	\|Bool		\|Bool
Line 204:		Line 204:
	\|Char		\|Char
	\|E.g.: 'A'		\|E.g.: 'A'
			\|-
			\|String
			\|Type synonym of '''[Char]'''.
	\|}		\|}

Savoundg at 07:14, 2 October 2016

2016-10-02T07:14:09Z

← Older revision		Revision as of 07:14, 2 October 2016
Line 1:		Line 1:
	== Notes on Haskell ==		== Notes on Haskell ==

	=== List<ref>http://learnyouahaskell.com/starting-out#an-intro-to-lists</ref> ===		=== List<ref name="list">http://learnyouahaskell.com/starting-out#an-intro-to-lists</ref> ===
	A list is a data structure that stores element of same type in a specific order. A list can be infinite or finite.		A list is a data structure that stores element of same type in a specific order. A list can be infinite or finite.

Line 222:		Line 222:
	</syntaxhighlight>		</syntaxhighlight>

	==== Pattern matching<ref>https://www.haskell.org/tutorial/patterns.html</ref> ====		==== Pattern matching<ref name="pattern">https://www.haskell.org/tutorial/patterns.html</ref> ====
	<syntaxhighlight lang="haskell">		<syntaxhighlight lang="haskell">
	length' :: [a] -> Integer		length' :: [a] -> Integer
Line 229:		Line 229:
	</syntaxhighlight>'''"_"''' is called the wild-card.		</syntaxhighlight>'''"_"''' is called the wild-card.

	==== Guards<ref~~>https:~~/~~/www.haskell.org/tutorial/patterns.html</ref~~> ====		==== Guards<ref name="pattern" /> ====
	<syntaxhighlight lang="haskell">		<syntaxhighlight lang="haskell">
	lengthTell :: [a] -> String		lengthTell :: [a] -> String
Line 241:		Line 241:
	</syntaxhighlight>		</syntaxhighlight>

	==== Case expression<ref~~>https:~~/~~/www.haskell.org/tutorial/patterns.html</ref~~> ====		==== Case expression<ref name="pattern" /> ====
	<syntaxhighlight lang="haskell">		<syntaxhighlight lang="haskell">
	length'' :: [a] -> Integer		length'' :: [a] -> Integer

Savoundg at 03:12, 18 July 2016

2016-07-18T03:12:37Z

← Older revision		Revision as of 03:12, 18 July 2016
Line 351:		Line 351:
	\|		\|
	\|Float, Double		\|Float, Double
			\|
			\|
			\|-
			\|RandomGen
			\|
			\|StdGen
			\|
			\|
			\|-
			\|Random
			\|
			\|
	\|		\|
	\|		\|
Line 591:		Line 603:
	\|<syntaxhighlight lang="haskell">		\|<syntaxhighlight lang="haskell">
	renameFile :: FilePath -> FilePath -> IO ()		renameFile :: FilePath -> FilePath -> IO ()
			</syntaxhighlight>
			\|-
			\|doesFileExist
			\|
			\|<syntaxhighlight lang="haskell">
			doesFileExist :: FilePath -> IO Bool
	</syntaxhighlight>		</syntaxhighlight>
	\|}		\|}
Line 614:		Line 632:

	===== Random =====		===== Random =====
			Import '''System.Random''' to use these functions.
	{\| class="wikitable"		{\| class="wikitable"
	!Function		!Function
Line 621:		Line 640:
	\|mkStdGen		\|mkStdGen
	\|		\|
	\|		\|Takes an integer and produces a random generator.
	\|-		\|-
	\|random		\|random
	\|		\|<syntaxhighlight lang="haskell">
	\|		random (mkStdGen 100) :: (Int, StdGen)
			</syntaxhighlight>
			\|Takes a random generator and returns couple of the type of the random value and a new random generator. You have to precise the type because it cannot guess the type of the wanted random value.
	\|-		\|-
	\|randoms		\|randoms
	\|		\|
	\|		\|Takes a random generator and returns an infinite sequence of random value.
	\|-		\|-
	\|randomR		\|randomR
Line 648:		Line 669:
	\|}		\|}

	===== ~~Bytestream~~ =====		===== Bytestring =====
			Import '''Data.ByteString''' or '''Data.ByteString.Lazy''' to use these functions.
	{\| class="wikitable"		{\| class="wikitable"
	!Function		!Function
Line 656:		Line 678:
	\|pack		\|pack
	\|		\|
	\|		\|Takes a list of byte (8-bit) and returns a ''ByteString''.<syntaxhighlight lang="haskell">
			pack :: [Word8] -> ByteString
			</syntaxhighlight>
	\|-		\|-
	\|unpack		\|unpack
	\|		\|
	\|		\|This is the inverse of ''pack''. Takes a ''ByteString'' and returns a list of ''Word8.''
	\|-		\|-
	\|fromChunks		\|fromChunks
	\|		\|
	\|		\|Takes a list of strict ''ByteString'' and returns a lazy ByteString.
	\|-		\|-
	\|toChunks		\|toChunks
	\|		\|
	\|		\|This is the inverse of ''fromChunks''.
	\|-		\|-
	\|cons		\|cons
	\|		\|
	\|		\|Takes a byte and a ByteString and put the byte at the beginning of the ByteString.
	\|-		\|-
	\|cons'		\|cons'
	\|		\|
	\|		\|Strict version of ''cons''.
	\|-		\|-
	\|empty		\|empty
	\|		\|
	\|		\|Returns an empty ''ByteString''.
	\|}		\|}

	===== Exception =====		===== I/O Exception =====
			Import '''System.IO.Error''' to use these functions.
	{\| class="wikitable"		{\| class="wikitable"
	!Function		!Function
Line 689:		Line 714:
	!Comments		!Comments
	\|-		\|-
	\|~~doesFileExist~~		\|catch
	\|		\|
	\|		\|
Line 701:		Line 726:
	\|		\|
	\|}		\|}

	~~catch~~

	reads		reads

Savoundg: I/O Action on Files and Arguments

2016-07-18T00:56:32Z

I/O Action on Files and Arguments

← Older revision		Revision as of 00:56, 18 July 2016
Line 530:		Line 530:
	\|-		\|-
	\|withFile		\|withFile
	\|		\|<syntaxhighlight lang="haskell">
	\|		main = do withFile "passwd.hs" ReadMode (\handle -> hGetContents handle >>= putStr)
			</syntaxhighlight>
			\|Takes the path of a File, the IOMode and a lambda of the following type (Handle -> IO a).
	\|-		\|-
	\|hGetLine		\|hGetLine
	\|		\|
	\|		\|Similar to getLine and operate on a handle.
	\|-		\|-
	\|hPutStr		\|hPutStr
	\|		\|
	\|		\|Similar to putStr and operate on a handle.
	\|-		\|-
	\|hPutStrLn		\|hPutStrLn
	\|		\|
	\|		\|Similar to putStrLn and operate on a handle.
	\|-		\|-
	\|hGetChar		\|hGetChar
	\|		\|
	\|		\|Similar to getChar operate on a handle.
	\|-		\|-
	\|readFile		\|readFile
	\|		\|<syntaxhighlight lang="haskell">
	\|		main = do readFile "passwd.hs" >>= putStr
			</syntaxhighlight>
			\|<syntaxhighlight lang="haskell">
			readFile :: FilePath -> IO String
			</syntaxhighlight>
	\|-		\|-
	\|writeFile		\|writeFile
	\|		\|<syntaxhighlight lang="haskell">
	\|		main = do writeFile "coucou" "toto"
			</syntaxhighlight>
			\|Write "toto" in the file ''coucou''.
	\|-		\|-
	\|appendFile		\|appendFile
	\|		\|<syntaxhighlight lang="haskell">
	\|		main = do appendFile "coucou" "toto"
			</syntaxhighlight>
			\|Append "toto" to the file ''coucou''.
	\|-		\|-
	\|hFlush		\|hFlush
	\|		\|
	\|		\|Takes a file handle and returns an I/O action that flush the file.
	\|-		\|-
	\|openTempFile		\|openTempFile
	\|		\|
	\|		\|<syntaxhighlight lang="haskell">
			openTempFile :: FilePath -> String -> IO (FilePath, Handle)
			</syntaxhighlight>
	\|-		\|-
	\|removeFile		\|removeFile
	\|		\|
	\|		\|<syntaxhighlight lang="haskell">
			removeFile :: FilePath -> IO ()
			</syntaxhighlight>
	\|-		\|-
	\|renameFile		\|renameFile
	\|		\|
	\|		\|<syntaxhighlight lang="haskell">
			renameFile :: FilePath -> FilePath -> IO ()
			</syntaxhighlight>
	\|}		\|}

Line 586:		Line 602:
	\|getArgs		\|getArgs
	\|		\|
	\|		\|<syntaxhighlight lang="haskell">
			getArgs :: IO [String]
			</syntaxhighlight>
	\|-		\|-
	\|getProgName		\|getProgName
	\|		\|
	\|		\|<syntaxhighlight lang="haskell">
			getProgName :: IO String
			</syntaxhighlight>
	\|}		\|}

Savoundg: /* Basic functions */

2016-06-27T00:21:36Z

Basic functions

← Older revision		Revision as of 00:21, 27 June 2016
Line 500:		Line 500:
	\|-		\|-
	\|getContents		\|getContents
	\|		\|<syntaxhighlight lang="haskell">
	\|		main = do fmap (map toUpper) getContents >>= putStr
			</syntaxhighlight>
			\|Gets the content of the standard input until the end-of-file character.

			The given example will read the input from the standard input and print it in uppercase.
	\|-		\|-
	\|interact		\|interact
	\|		\|<syntaxhighlight lang="haskell">
	\|		main = do interact (map toUpper)
			</syntaxhighlight>
			\|Takes a function String -> String as a parameter and returns an I/O action that takes the input, executes the given function and prints the result.
	\|-		\|-
	\|openFile		\|openFile
			\|<syntaxhighlight lang="haskell">
			import System.IO

			main = do openFile "passwd.hs" ReadMode >>= hClose
			</syntaxhighlight>
			\|Takes the path of a File and an IOMode and returns an I/O action that holds the file handle ''Handle''.
			\|-
			\|hClose
	\|		\|
	\|		\|Takes a file handle and returns an I/O action that closes the file.
	\|-		\|-
	\|hGetContents		\|hGetContents
	\|		\|
	\|		\|Takes a file handle and returns an I/O action that holds the content of the file.
	\|-		\|-
	\|withFile		\|withFile

Savoundg: /* Arguments */

2016-06-20T07:00:08Z

Arguments

← Older revision		Revision as of 07:00, 20 June 2016
Line 564:		Line 564:
	\|}		\|}

	====== Arguments ======		===== Arguments =====
	{\| class="wikitable"		{\| class="wikitable"
	!Function		!Function
Line 651:		Line 651:
	===== Exception =====		===== Exception =====
	{\| class="wikitable"		{\| class="wikitable"
	!		!Function
	!		!Example
	!		!Comments
	!
	\|-		\|-
	\|doesFileExist		\|doesFileExist
	\|
	\|		\|
	\|		\|
	\|-		\|-
	\|
	\|		\|
	\|		\|
	\|		\|
	\|-		\|-
	\|
	\|		\|
	\|		\|