Преобразование строки в пользовательский тип.Проблема ввода-вывода

Question

Hello: У меня есть функция, которая получает строку, и в отношении того, что она получает, она вызывает некоторые другие функции. Все, кроме одного, не нуждаются в аргументах. Но тот, кому это нужно, ожидает получения аргумента, тип которого определен мной. Мое намерение состоит в том, чтобы требовать ввода для прохождения. Но, используя getLine, getChar, getInt, сохраняйте ввод, сохраняя тип ([Char], Char и т. Д.), И мне нужно передать грубый ввод этой функции, чтобы система логического вывода могла определить, что ее тип - мой пользователь. определенный тип (Fecha).

Выдержки из кода:

type Fecha = [(NombreJug,PuntosLogrados,MinutosJugados)]

armarListaDeTuplasPuntosFecha::Fecha->[(NombreJug,PuntosLogrados)]
armarListaDeTuplasPuntosFecha [] = []
armarListaDeTuplasPuntosFecha (ej:ejs) = [((\ (nombre,puntos,_)-> (nombre,puntos)) ej)] ++ armarListaDeTuplasPuntosFecha ejs


**jugadorConMayorCantidadDePuntoEnFecha unaFecha** = (\ (nombre,puntos)->nombre) (maximumBy mayorTupla (armarListaDeTuplasPuntosFecha unaFecha))

mejorJugadorPor::String->NombreJug
mejorJugadorPor criterio | criterio == "Mayor Cantidad de puntos en fecha" = do

                 fecha<-getLine                          
                 jugadorConMayorCantidadDePuntoEnFecha (fecha)
             | otherwise = "No es un criterio valido, reintente una proxima vez"

Буду очень признателен, если вы поможете мне с этим вопросом. Доступная документация мне показалась недостаточной из-за того, что я новичок в Haskell

Заранее большое спасибо.

Привет

Answer 1

Похоже, он пытается отслеживать игроков (NombreJug = имя игрока), PuntosLogrados (набранные очки) и время игры (MinutosJugados), а затем найти лучшего игрока по некоторым критериям.

armarListaDeTuplasPuntosFecha отбрасывает время воспроизведения, чтобы вернуть кортеж имени и очков игрока.

mejorJugadorPor («Лучший игрок по») пытается запросить у пользователя список входных данных и затем выбратьигрок с самым высоким счетом.Я думаю, вы правы, что ему нужен экземпляр Read для его типа или функция для анализа ввода и преобразования его в тип Fecha, определенный в верхней части.Это также зависит от того, как определены NombreJug, PuntosLogrados, MinutosJugados.Являются ли они синонимами типа?

mejorJugadorPor также выглядит так, как будто он должен иметь тип String-> IO NombreJug, поскольку он выполняет действия ввода-вывода.

---

Это моя попытка сделать то, что вы хотите:

import Data.List

type NombreJug = String
type PuntosLogrados = Int
type MinutosJugados = Int

type Fecha = [(NombreJug,PuntosLogrados,MinutosJugados)]

armarListaDeTuplasPuntosFecha::Fecha->[(NombreJug,PuntosLogrados)]
armarListaDeTuplasPuntosFecha = map desechar
    where desechar (x,y,_) = (x,y)

jugadorConMayorCantidadDePuntoEnFecha unaFecha = fst (maximumBy mayorTupla (armarListaDeTuplasPuntosFecha unaFecha))

mayorTupla = undefined

mejorJugadorPor:: String -> IO NombreJug
mejorJugadorPor criterio 
    | criterio == "Mayor Cantidad de puntos en fecha" = do
                 fecha <- readLn                           
                 return $ jugadorConMayorCantidadDePuntoEnFecha fecha
    | otherwise = return "No es un criterio valido, reintente una proxima vez"

Я добавил «mayorTupla = undefined», чтобы получить его для компиляции, потому что эта функция не определена вкод, который вы отправили.

Изменения, которые я сделал:

1. ваша функция armarListaDeTuplasPuntosFecha лучше выражена с помощью map.Map применяет функцию к каждому элементу списка, что вы и делаете вручную.

2. jugadorConMayorCantidadDePuntoEnFecha можно выразить с помощью fst, который возвращает первый элемент кортежа из двух значений

3. mejorJugadorPor должен находиться в монаде ввода-вывода, потому что он выполняет действия ввода / вывода (читая что-то, что пользователь вводит).Вы делаете это, изменяя тип возвращаемого значения со String на IO String, чтобы сказать, что возвращаемое значение зависит от IO (то есть функция не является чистой).

4. Функция readLn делает то, чтовы хотите, потому что он преобразует входную строку в правильный тип, если у типа есть экземпляр Read.Класс чтения типа в основном означает, что вы можете каким-то образом преобразовать строку в значение типа.

5. Поскольку mejorJugadorPor является монадическим, вам необходимо убедиться, что возвращаемое значение содержится вмонада IO.Вот что делает возвращаемая функция: она принимает значение типа «a» и превращает его в значение типа «ma», где m - любая монада.

Answer 2

Через несколько часов я справился с беспорядком: с помощью Великобритании (Джулиан Портер: www.jpembedded.co.uk, www.porternet.org).Есть способ не создавать монады или модифицировать классы (я еще не на этом уровне):

import Data.List

type NombreJug = String
type NombrePart = String
type Club = String
type Posicion = String
type Cotizacion = Integer
type PuntosLogrados = Integer
type MinutosJugados = Integer
type Jugador = (NombreJug,Club,Posicion,Cotizacion)
type Jugadores = [Jugador]
type PartConSusJug = (NombrePart,[NombreJug])
type Participantes = [PartConSusJug]
type Fecha = [(NombreJug,PuntosLogrados,MinutosJugados)]
type Fechas = [Fecha]

participantes = [("Natalia", ["Abbondazieri","Lluy","Battaglia", "Lazzaro"]),
                 ("Romina",  ["Islas", "Lluy", "Battaglia", "Lazzaro"]),
                 ("Jessica", ["Islas"])
                                      ]


clubes = ["Boca", "Racing", "Tigre"]


jugadores = [("Abbondazieri", "Boca", "Arquero", 6500000),
                ("Islas", "Tigre", "Arquero", 5500000),
                ("Lluy", "Racing", "Defensor", 1800000),
                ("Battaglia", "Boca", "Volante", 8000000),
                ("Lazzaro", "Tigre", "Delantero", 5200000),
            ("Monzon","Boca","Defensor",3500000),
            ("Guzman","Newells","Arquero",1000000),
            ("Diaz","Velez","Defensor",3600000),
            ("Palermo","Boca","Delantero",12000000),
            ("Aguirre","Lanus","Volante",4500000),
            ("Cura","Huracan","Defensor",1700000),
            ("Espinoza","Gimnasia","Volante",300000),
            ("Clemente","Deportivo Piraña","Volante",60000000)
                                         ]
miListaTuplasFechas = [("quinta",[("Lluy", 8, 90),("Lazzaro", 6, 90)]),("sexta",[("Lazzaro", 7, 77),("Islas", 6, 90),("Lluy", 7, 90)]),("septima",[("Battaglia", 13, 90), ("Lluy", 6, 90), ("Lazzaro", 8, 77)]),("octava",[("Islas", 4, 84), ("Battaglia", 8, 90)])] 


fechas = [quinta, sexta, septima, octava]


quinta  = [("Lluy", 8, 90), ("Lazzaro", 6, 90)]
sexta   = [("Lazzaro", 7, 77), ("Islas", 6, 90), ("Lluy", 7, 90)]
septima = [("Battaglia", 13, 90), ("Lluy", 6, 90), ("Lazzaro", 8, 77)]
octava  = [("Islas", 4, 84), ("Battaglia", 8, 90)]

-- 10)  mejorJugadorPor, recibe un criterio y devuelve el mejor jugador de acuerdo a ese criterio.
-- Dar además ejemplos de consultas que resuelvan los siguientes requerimientos:


mayorTupla (n1, c1) (n2, c2)
  | c1 > c2 = GT
  | c1 <= c2 = LT


-- 1.el jugador que logro mayor cantidad de puntos en todo el torneo. -> "Lazzaro"


armarListaDeTuplasPuntos::Jugadores->[(NombreJug,PuntosLogrados)]
armarListaDeTuplasPuntos [] = []
armarListaDeTuplasPuntos (ej:ejs) = [ (((\ (nombre,_,_,_)-> nombre) ej), (totalPuntosJugador ((\ (nombre,_,_,_)-> nombre) ej))) ] ++ armarListaDeTuplasPuntos ejs


mostrarmeLasTuplasPuntos = armarListaDeTuplasPuntos jugadores


jugadorConMayorCantidadDePuntosEnTorneo = (\ (nombre,puntos)->nombre) (maximumBy mayorTupla mostrarmeLasTuplasPuntos)


-- 2.el jugador que posee la mayor cotización.-> "Battaglia"


armarListaDeTuplasCotizacion::Jugadores->[(NombreJug,Cotizacion)]
armarListaDeTuplasCotizacion [] = []
armarListaDeTuplasCotizacion (ej:ejs) = [((\ (nombre,_,_,cotizacion)-> (nombre,cotizacion)) ej)] ++ armarListaDeTuplasCotizacion ejs


mostrarmeLasTuplasCotizaciones = armarListaDeTuplasCotizacion jugadores


jugadorConLaMayorCotizacion = (\ (nombre,cotizacion)->nombre) (maximumBy mayorTupla mostrarmeLasTuplasCotizaciones)
--Aquí se ve un ejemplo de aplicación de orden superior: la función maximumBy recibe dos funciones como agumentos.

-- 3.el jugador que logro mayor cantidad de puntos en una fecha. (en la 5º) -> "Lluy"


armarListaDeTuplasPuntosFecha::Fecha->[(NombreJug,PuntosLogrados)]
armarListaDeTuplasPuntosFecha [] = []
armarListaDeTuplasPuntosFecha (ej:ejs) = [((\ (nombre,puntos,_)-> (nombre,puntos)) ej)] ++ armarListaDeTuplasPuntosFecha ejs



jugadorConMayorCantidadDePuntoEnFecha [] = "Fecha no definida"
jugadorConMayorCantidadDePuntoEnFecha unaFecha = (\ (nombre,puntos)->nombre) (maximumBy mayorTupla (armarListaDeTuplasPuntosFecha unaFecha))


-- 4.el jugador que logro el mejor promedio en todo el torneo. ->  "Battaglia"


armarListaDeTuplasPromedios::Jugadores->[(NombreJug,Float)]
armarListaDeTuplasPromedios [] = []
armarListaDeTuplasPromedios (ej:ejs) = [ (((\ (nombre,_,_,_)-> nombre) ej), (promedioPuntosJugador ((\ (nombre,_,_,_)-> nombre) ej))) ] ++ armarListaDeTuplasPromedios ejs 


mostrarmeLasTuplasPromedios = armarListaDeTuplasPromedios jugadores


jugadorConMejorPromedioDelTorneo = (\ (nombre,puntos)->nombre) (maximumBy mayorTupla mostrarmeLasTuplasPromedios)
--Aquí se ve un ejemplo de aplicación de orden superior: la función mostrarmeLasTuplasPromerios es pasada como parámetro a la expresión lambda.


otroCaso = "No es un criterio valido, reintente una proxima vez"


listaDeCriterios criterio | (criterio == "jugadorConMayorCantidadDePuntosEnTorneo") = jugadorConMayorCantidadDePuntosEnTorneo
                  | (criterio == "jugadorConLaMayorCotizacion") = jugadorConLaMayorCotizacion
              | (criterio == "jugadorConMejorPromedioDelTorneo") = jugadorConMejorPromedioDelTorneo
                  | ((criterio /= "jugadorConMayorCantidadDePuntosEnTorneo")&& (criterio /= "jugadorConLaMayorCotizacion")&&(criterio /= "jugadorConMejorPromedioDelTorneo")) = otroCaso


devolverFecha::String->[(String,Fecha)]->Fecha
devolverFecha laFecha [] = []
devolverFecha laFecha (f:fs) | (((\ fechaIngresada (fechaAComparar,_)-> fechaIngresada == fechaAComparar) laFecha f) == True) = snd f
                 | otherwise = devolverFecha laFecha fs


criterios1 = do
   putStrLn "Ingrese la fecha deseada: "
   x<-getLine
   let resultado = ((jugadorConMayorCantidadDePuntoEnFecha (devolverFecha x miListaTuplasFechas)))
   putStrLn ("\""++resultado++"\"")


criterios2::String->IO ()
criterios2 criterio = do
   let resultado = (listaDeCriterios criterio)
   putStrLn ("\""++resultado++"\"")


eleccionDeCriterios criterioElegido | (criterioElegido == "jugadorConMayorCantidadDePuntoEnFecha") = criterios1
                            | otherwise = criterios2 criterioElegido


mejorJugadorPor = do
  putStrLn "Por favor, ingrese un criterio: "
  criterio<-getLine
  eleccionDeCriterios criterio

Вывод на консоль:

Main> mejorJugadorPor
Por favor, ingrese un criterio: 
jugadorConMejorPromedioDelTorneo
"Battaglia"

Main> mejorJugadorPor
Por favor, ingrese un criterio: 
pepe
"No es un criterio valido, reintente una proxima vez"

Main> 
Main> 
Main> mejorJugadorPor
Por favor, ingrese un criterio: 
jugadorConMayorCantidadDePuntoEnFecha
Ingrese la fecha deseada: 
quinta
"Lluy"

Main> mejorJugadorPor
Por favor, ingrese un criterio: 
jugadorConMayorCantidadDePuntoEnFecha
Ingrese la fecha deseada: 
decima
"Fecha no definida"

Это на испанском языке.Если кто-то найдет это полезным, свяжитесь со мной, и я переведу его на английский.

Большое спасибо тем, кто прокомментировал этот вопрос, и за их рекомендации.

Answer 3

Из того, что я мог собрать, вы хотите сделать экземпляры типов данных класса Read и затем использовать функцию чтения для чтения строковых данных в ваши типы данных.

Если это было не то, что вы имели в виду, дайте мне знать.