Заставить ReadArgs 1.0 работать с одним аргументом

Я не совсем понимаю все расширения, которые мне нужно было включить, но вы можете определить экземпляр ReadArgs.ArgumentTuple a (даже если это не совсем семантически правильное имя) следующим образом:

{-# LANGUAGE FlexibleInstances, UndecidableInstances,
             OverlappingInstances, ScopedTypeVariables #-}

import ReadArgs

instance (Argument a) => ArgumentTuple a where
  parseArgsFrom ss = do
    a :& () <- parseArgsFrom ss
    return a
  usageFor a = usageFor (a :& ())

main = do
    (foo :: Int) <- readArgs
    print foo

Кроме того, я не совсем уверен, есть ли какие-либо проблемы с этим экземпляром, хотя он работает для примера, который вы представили. Я предполагаю, что есть причина, по которой его нет в библиотеке, но я могу ошибаться.

Обновлять

Попробовав несколько вещей, чтобы убедиться, что они все еще работают (например, следующий пример), я совершенно убежден, что это не вызывает никаких проблем, поэтому, возможно, его (или что-то подобное) существование было просто недосмотром.

main = do
    (foo :: Int, bar :: Int) <- readArgs
    print foo
    print bar

Насколько я могу судить, пакет использует кортежи для эмуляции гетерогенных списков, безопасных для типов. Как вы заметили, это вызывает проблемы, когда вам нужен только один аргумент, поскольку в Haskell нет кортежей из одного элемента.

Однако пакет также предоставляет подходящий тип для разнородных списков, который можно использовать вместо кортежей: тип :&. Вы используете его аналогично оператору : с пустым кортежем () в качестве терминатора:

(foo :: Int) :& (bar :: String) :& () <- readArgs

Это работает тривиально с одним аргументом:

(foo :: Int) :& () <- readArgs

Другой ответ, просто для удовольствия: повторение предложения Даниэля Вагнера о добавлении экземпляра для OneTuple:

{-# LANGUAGE ScopedTypeVariables #-}

import ReadArgs
import Data.Tuple.OneTuple

instance (Argument a) => ArgumentTuple (OneTuple a) where
  parseArgsFrom ss = do
    a :& () <- parseArgsFrom ss
    return $ OneTuple a
  usageFor (OneTuple a) = usageFor (a :& ())

main = do
    OneTuple (foo :: Int) <- readArgs
    print foo

В основном украдено из решения Адама Вагнера. Удивительно, но все лишние языковые прагмы можно удалить.

Это может звучать глупо, но OneTuple (foo :: Int) <- readArgs не так уродлив, как я себе представлял по какой-то причине.

Одним из отсталых решений является злоупотребление функцией «необязательный аргумент»:

(foo :: Int, _ :: Maybe ()) <- readArgs

Это тихо работает, даже если вы укажете () в качестве второго аргумента:

$ runhaskell args.hs 3 ()
3

И немного портит сообщение об использовании:

$ runhaskell args.hs 3 foo
usage: args.hs Int [()]

Но он отклоняет дополнительные аргументы, отличные от (), и работает так, как хотелось бы:

$ runhaskell args.hs 3
3