Haskell Modules

concepts
1. Haskell Modules are a collection of related functions, types and type classes.
  1. Standard Haskell module is named prelude
    1. Modules are used to manipulate lists, concurrent programming, complex numbers, etc.
why use modules
1. Modules becomes reusables if they are enough generic
2. Modules make programs loosely coupled
3. Modules make more manageable by having it split into several parts
How to used
1. Aggregate import clause and the name of Module at the beginning of your script
  1. Add as imports as you need in separate lines
    1. When you do import Data.List, all the functions that Data.List exports become available in the global namespace
2. From ghci terminal you may use :m + <name module>
  1. Nota:
    - |
3. If you just need a couple of functions from a module, you can selectively import just those functions.
4. You might use hiding to exclude functions within modeles
5. You can use qualified imports to deal with clashes and add an alias to imports
Haskell Included modules
1. Data.List
  1. imterparse takes an element and a list and put the first arguent and put it between each element of the second argument list
  2. Intercalate function receives a list and a list of list and intercalate each element
  3. transpose function transposes a list of list
  4. concat function flatten a list of list in a single list
  5. concatMap: mapping a functionin a list and the concatenate
  6. 'and' and 'or' functions evaluates a predicate and return a boolean if condition accomplish
  7. any and all take a predicate and then check if any or all the elements in a list satisfy the predicate
  8. splitAt takes a number and a list. It then splits the list at that many elements
  9. takeWhile takes elements from a list while the predicate holds and then when an element is encountered that doesn't satisfy the predicate, it's cut off
  10. dropWhile drops all the elements while the predicate is true
2. Data.Map
  1. Association lists (also called dictionaries) are lists that are used to store key-value pairs where ordering doesn't matter.
    1. The fromList function takes an association list
    2. empty represents an empty map. It takes no arguments, it just returns an empty map.
    3. insert takes a key, a value and a map and returns a new map that's just like the old one, only with the key and value inserted
    4. null checks if a map is empty.
    5. size reports the size of a map.
    6. singleton takes a key and a value and creates a map that has exactly one mapping.
    7. member is a predicate takes a key and a map and reports whether the key is in the map or not.
    8. keys and elems return lists of keys and values respectively. keys is the equivalent of map fst . Map.toList and elems is the equivalent of map snd . Map.toList.
    9. fromListWith is a cool little function. It acts like fromList, only it doesn't discard duplicate keys but it uses a function supplied to it to decide what to do with them. Let's say that a girl can have several numbers and we have an association list set up like this.
    10. insertWith is to insert what fromListWith is to fromList. It inserts a key-value pair into a map, but if that map already contains the key, it uses the function passed to it to determine what to do.
3. Data.Char
  1. The Data.Char module does what its name suggests. It exports functions that deal with characters. It's also helpful when filtering and mapping over strings because they're just lists of characters.
    1. This module exports a bunch of predicates over characters
      1. isControl checks whether a character is a control character.
      2. isSpace checks whether a character is a white-space characters. That includes spaces, tab characters, newlines, etc.
      3. isLower and is Upper check is a character is upper or Lower case
      4. isAlpha checks whether a character is a letter.
      5. isAlphaNum checks whether a character is a letter or a number.
      6. isPrint checks whether a character is printable. Control characters, for instance, are not printable.
      7. isDigit checks whether a character is a digit.
      8. isLetter checks whether a character is a letter.
      9. isNumber checks whether a character is numeric.
      10. isSymbol checks whether a character is a fancy mathematical or currency symbol.
      11. isSeparator checks for Unicode spaces and separators.
      12. isAscii checks whether a character falls into the first 128 characters of the Unicode character set.
      13. isAsciiUpper or isAsciiLower check if is an ASCII is upper or lower case
4. Data.Set
  1. Sets are kind of like a cross between lists and maps. All the elements in a set are unique. And because they're internally implemented with trees (much like maps in Data.Map), they're ordered.
    1. The fromList function works much like you would expect.
    2. We can use the difference function to see which letters are in the first set but aren't in the second one and vice versa.
    3. we can see all the unique letters used in both sentences by using union.
Making our own modules
1. Haskell allow us as many other lenguages to create our own modules
  1. We should create a file named with *.hs, the fist letter of the file should be in upper case
    1. At the beginning of a module, we specify the module name
      1. Then we defined the functions the will be included within de module
        Following we shold implement the functions we alredy define at the beginning of the module

Siguiente

Haskell Modules

Descripción

Resumen del Recurso

Recursos multimedia adjuntos

Similar

	Creado por TABARES ROMERO DIEGO MAURICIO hace alrededor de 4 años