Introducción
Listas
Una list en F# es una colección inmutable de cero o más valores. Todos los valores de una lista deben tener el mismo tipo. Como las listas son inmutables, una vez que se ha construido una lista, su valor nunca puede cambiar. Cualquier función u operador que parezca modificar una lista (como añadir un elemento) en realidad devolverá una nueva lista.
Las listas se pueden definir de la siguiente manera:
let empty = []
let singleValue = [5]
let threeValues = ["a"; "b"; "c"]
La forma más común de añadir un elemento a una lista es mediante el operador :: (cons):
let twoToFour = [2; 3; 4]
let oneToFour = 1 :: twoToFour
// => [1; 2; 3; 4]
Una lista de F# tiene una cabeza (el primer elemento) y una cola (todo lo que sigue al primer elemento). La cola de una lista es en sí misma una lista.
Las listas se manipulan mediante funciones y operadores definidos en el módulo List, o manualmente usando la coincidencia de patrones con los patrones lista y cons:
let describe list =
match list with
| [] -> "Empty list"
| head::tail -> sprintf "Non-empty list with head: %d" head
describe [] // => "Empty list"
describe [1] // => "Non-empty with head: 1"
describe [5; 7; 9] // => "Non-empty with head: 5"
También puedes descartar un valor al hacer coincidencia de patrones; cuando no te importa un valor en un caso concreto (es decir, no vas a usar un valor), puedes usar un guion bajo ('_') para indicarlo:
let describe list =
match list with
| [] -> "Empty list"
| [x] -> "List with one item"
| [_; y] -> "List with two items (first item ignored)"
| _ -> "List with many items (all items ignored)"
describe [] // => "Empty list"
describe [1] // => "List with one item"
describe [5; 7] // => "List with two items (first item ignored)"
describe [5; 7; 9] // => "List with many items (all items ignored)"
El '_' por sí solo debe ir siempre al final en la coincidencia de patrones; todo valor que no coincida con ninguno de los otros casos será manejado por este caso.
Instrucciones
En este ejercicio vas a escribir código para llevar un registro de un array de lenguajes de programación que quieres aprender en Exercism.
Tienes seis tareas, y todas ellas implican trabajar con arrays.
1. Crea un array nuevo
Para llevar un registro de los lenguajes que quieres aprender, necesitarás crear un array nuevo. Define el binding newList que contiene un array nuevo y vacío.
newList
// => []
2. Define un array existente
Actualmente tienes una hoja de papel en la que figuran los lenguajes que quieres aprender: F#, Clojure y Haskell. Define el binding existingList para representar este array.
existingList
// => ["F#"; "Clojure"; "Haskell"]
3. Añade un lenguaje nuevo a un array
A medida que explores Exercism y encuentres lenguajes más interesantes, querrás añadirlos a tu array. Implementa la función addLanguage para añadir un lenguaje nuevo al principio de tu array.
addLanguage "TypeScript" ["JavaScript"; "CoffeeScript"]
// => ["TypeScript"; "JavaScript"; "CoffeeScript"]
4. Cuenta los lenguajes del array
Contar los lenguajes uno a uno es incómodo. Implementa la función countLanguages para contar cuántos lenguajes hay en tu array.
countLanguages ["C#"; "Racket"; "Rust"; "Ruby"]
// => 4
5. Invierte el array
¡Llega un momento en el que te das cuenta de que tu array está ordenado al revés! Implementa la función reverseList para invertir tu array.
reverseList ["Prolog"; "C"; "Idris"; "Assembly"]
// => ["Assembly"; "Idris"; "C"; "Prolog"]
6. Comprueba si el array es emocionante
Aunque te encantan todos los lenguajes, F# tiene un lugar especial en tu corazón. Por eso, un array de lenguajes te entusiasma mucho si:
- El primero del array es F#.
- El segundo elemento del array es F# y el array contiene dos o tres lenguajes.
Implementa la función excitingList para comprobar si un array de lenguajes es emocionante:
excitingList ["Nim"; "F#"]
// => true
Ejercicio de aprendizaje
