-- |
-- Module      :  Composition.Sound.ParseList
-- Copyright   :  (c) OleksandrZhabenko 2020-2021
-- License     :  MIT
-- Stability   :  Experimental
-- Maintainer  :  olexandr543@yahoo.com
--
-- Helps to create experimental music from a file (or its part) and a Ukrainian text. 
-- It can also generate a timbre for the notes. Uses SoX inside.

{-# OPTIONS_GHC -threaded #-}

module Composition.Sound.ParseList where 

import Data.Char (isSpace)
--import qualified Data.Vector as V
import Data.List
import Data.Maybe (mapMaybe)
import Text.Read (lex,readMaybe)
import Data.Maybe (isNothing,fromMaybe)

parseTup :: String -> [String]
parseTup :: String -> [String]
parseTup String
xs = ((String, String) -> String) -> [(String, String)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map ((Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isSpace (String -> String)
-> ((String, String) -> String) -> (String, String) -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, String) -> String
forall a b. (a, b) -> a
fst) (((String, String) -> Bool)
-> [(String, String)] -> [(String, String)]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile ((String, String) -> (String, String) -> Bool
forall a. Eq a => a -> a -> Bool
/= (String
"",String
"")) ([(String, String)] -> [(String, String)])
-> ((String, String) -> [(String, String)])
-> (String, String)
-> [(String, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((String, String) -> (String, String))
-> (String, String) -> [(String, String)]
forall a. (a -> a) -> a -> [a]
iterate ([(String, String)] -> (String, String)
forall a. [a] -> a
head ([(String, String)] -> (String, String))
-> ((String, String) -> [(String, String)])
-> (String, String)
-> (String, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadS String
lex ReadS String
-> ((String, String) -> String)
-> (String, String)
-> [(String, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, String) -> String
forall a b. (a, b) -> b
snd) ((String, String) -> [(String, String)])
-> (String, String) -> [(String, String)]
forall a b. (a -> b) -> a -> b
$ [(String, String)] -> (String, String)
forall a. [a] -> a
head (ReadS String
lex String
xs))

containsExt :: [String] -> Bool
containsExt :: [String] -> Bool
containsExt = String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem String
".." 

-- | Predicate to check whether a list does not contain round parentheses or dash (a minus sign) as its elements. Is used internally in the
-- 'parseStoLInts' function to avoid lists with negative elements.
canBePreParseV :: [String] -> Bool
canBePreParseV :: [String] -> Bool
canBePreParseV (String
xs:[String]
xss) = case String
xs of { String
"(" -> Bool
False ; String
"-" -> Bool
False ; String
")" -> Bool
False ; ~String
bbb -> [String] -> Bool
canBePreParseV [String]
xss }
canBePreParseV [String]
_ = Bool
True

-- | Notification. Uses an 'Int' limitation to avoid infinite lists. All arguments must be not negative.
parseV :: Int -> [String] -> Maybe [Int]
parseV :: Int -> [String] -> Maybe [Int]
parseV Int
n [String]
v
 | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
2] Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
4 = 
    if [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&&  ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
3) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]"
      then let ins1 :: Maybe Int
ins1 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
1)::Maybe Int in
        case Maybe Int
ins1 of
          Just Int
ins -> if Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
ins then [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins] else [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins..Int
n]
          Maybe Int
Nothing  -> Maybe [Int]
forall a. Maybe a
Nothing
      else Maybe [Int]
forall a. Maybe a
Nothing
 | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
2] Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
5 =
    if [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
4 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]"
      then let ins1 :: Maybe Int
ins1 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
1)::Maybe Int 
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
3)::Maybe Int in
        case (Maybe Int
ins1,Maybe Int
ins2) of
          (Just Int
ins01,Just Int
ins02) -> if Int
ins02 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
ins01 then [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins01..Int
ins02] else Maybe [Int]
forall a. Maybe a
Nothing
          (Maybe Int, Maybe Int)
_                       -> Maybe [Int]
forall a. Maybe a
Nothing
      else Maybe [Int]
forall a. Maybe a
Nothing
 | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
4] Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
6 =
    if [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
2 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"," Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
5 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]" 
      then let ins1 :: Maybe Int
ins1 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
1)::Maybe Int 
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
3)::Maybe Int in
        case (Maybe Int
ins1,Maybe Int
ins2) of
          (Just Int
ins01,Just Int
ins02) ->
            case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
ins02 Int
ins01 of
             Ordering
GT -> if Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
n Int
ins02 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT then [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins01,Int
ins02..Int
n] else [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins01,Int
ins02]
             Ordering
EQ -> [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins01]
             Ordering
_  -> [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins01,Int
ins02..Int
0]
          (Maybe Int, Maybe Int)
_                       -> Maybe [Int]
forall a. Maybe a
Nothing
      else Maybe [Int]
forall a. Maybe a
Nothing
 | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
4] Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
7 =
    if [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
2 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"," Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
6 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]" 
      then let ins1 :: Maybe Int
ins1 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
1)::Maybe Int 
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
3)::Maybe Int
               ins3 :: Maybe Int
ins3 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
5)::Maybe Int in
        case (Maybe Int
ins1,Maybe Int
ins2,Maybe Int
ins3) of
          (Just Int
ins01,Just Int
ins02,Just Int
ins03) -> if [Int] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Int
ins01,Int
ins02..Int
ins03] then Maybe [Int]
forall a. Maybe a
Nothing else [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins01,Int
ins02..Int
ins03]
          (Maybe Int, Maybe Int, Maybe Int)
_                       -> Maybe [Int]
forall a. Maybe a
Nothing
      else Maybe [Int]
forall a. Maybe a
Nothing
 | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! ([String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]" Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
2 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 Bool -> Bool -> Bool
&&
    (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
",") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
2,Int
4..([String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
2)] =
      let insV1 :: [Maybe Int]
insV1 = ((Int, String) -> Maybe Int) -> [(Int, String)] -> [Maybe Int]
forall a b. (a -> b) -> [a] -> [b]
map (\(Int
i, String
_) -> String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! (Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))::Maybe Int) ([(Int, String)] -> [Maybe Int])
-> ([String] -> [(Int, String)]) -> [String] -> [Maybe Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [String] -> [(Int, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([String] -> [(Int, String)])
-> ([String] -> [String]) -> [String] -> [(Int, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [String] -> [String]
forall a. Int -> [a] -> [a]
take ([String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
2) ([String] -> [Maybe Int]) -> [String] -> [Maybe Int]
forall a b. (a -> b) -> a -> b
$ [String]
v in
       if (Maybe Int -> Bool) -> [Maybe Int] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Maybe Int -> Bool
forall a. Maybe a -> Bool
isNothing [Maybe Int]
insV1
         then Maybe [Int]
forall a. Maybe a
Nothing
         else [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just ((Maybe Int -> Maybe Int) -> [Maybe Int] -> [Int]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Maybe Int -> Maybe Int
forall a. a -> a
id [Maybe Int]
insV1)
 | Bool
otherwise = Maybe [Int]
forall a. Maybe a
Nothing

-- | From the 0.19.0.0 version. Can be used to parse also into infinite lists. 
parseVInf :: [String] -> Maybe [Int]
parseVInf :: [String] -> Maybe [Int]
parseVInf [String]
v
 | (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
2] Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
4 =
    if [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
3 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]"
      then let ins1 :: Maybe Int
ins1 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
1)::Maybe Int in
        case Maybe Int
ins1 of
          Just Int
ins -> [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins..]
          Maybe Int
Nothing  -> Maybe [Int]
forall a. Maybe a
Nothing
      else Maybe [Int]
forall a. Maybe a
Nothing
 | (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
2] Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
5 =
    if [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
4 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]"
      then let ins1 :: Maybe Int
ins1 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
1)::Maybe Int
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
3)::Maybe Int in
        case (Maybe Int
ins1,Maybe Int
ins2) of
          (Just Int
ins01,Just Int
ins02) -> if Int
ins02 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
ins01 then [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins01..Int
ins02] else Maybe [Int]
forall a. Maybe a
Nothing
          (Maybe Int, Maybe Int)
_                       -> Maybe [Int]
forall a. Maybe a
Nothing
      else Maybe [Int]
forall a. Maybe a
Nothing
 | (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
4] Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
6 =
    if [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
2 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"," Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
5 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]"
      then let ins1 :: Maybe Int
ins1 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
1)::Maybe Int
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
3)::Maybe Int in
        case (Maybe Int
ins1,Maybe Int
ins2) of
          (Just Int
ins01,Just Int
ins02) -> [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins01,Int
ins02..]
          (Maybe Int, Maybe Int)
_                       -> Maybe [Int]
forall a. Maybe a
Nothing
      else Maybe [Int]
forall a. Maybe a
Nothing
 | (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
4] Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
7 =
    if [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
2 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"," Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
6 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]"
      then let ins1 :: Maybe Int
ins1 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
1)::Maybe Int
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
3)::Maybe Int
               ins3 :: Maybe Int
ins3 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! Int
5)::Maybe Int in
        case (Maybe Int
ins1,Maybe Int
ins2,Maybe Int
ins3) of
          (Just Int
ins01,Just Int
ins02,Just Int
ins03) -> if [Int] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Int
ins01,Int
ins02..Int
ins03] then Maybe [Int]
forall a. Maybe a
Nothing else [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just [Int
ins01,Int
ins02..Int
ins03]
          (Maybe Int, Maybe Int, Maybe Int)
_                       -> Maybe [Int]
forall a. Maybe a
Nothing
      else Maybe [Int]
forall a. Maybe a
Nothing
 | [String] -> String
forall a. [a] -> a
head [String]
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& [String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! ([String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"]" Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
2 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 Bool -> Bool -> Bool
&&
    (String -> Bool) -> [String] -> [Int]
forall a. (a -> Bool) -> [a] -> [Int]
findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
",") [String]
v [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
2,Int
4..([String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
2)] =
      let insV1 :: [Maybe Int]
insV1 = ((Int, String) -> Maybe Int) -> [(Int, String)] -> [Maybe Int]
forall a b. (a -> b) -> [a] -> [b]
map (\(Int
i, String
_) -> String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe ([String]
v [String] -> Int -> String
forall a. [a] -> Int -> a
!! (Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))::Maybe Int) ([(Int, String)] -> [Maybe Int])
-> ([String] -> [(Int, String)]) -> [String] -> [Maybe Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [String] -> [(Int, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([String] -> [(Int, String)])
-> ([String] -> [String]) -> [String] -> [(Int, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [String] -> [String]
forall a. Int -> [a] -> [a]
take ([String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
2) ([String] -> [Maybe Int]) -> [String] -> [Maybe Int]
forall a b. (a -> b) -> a -> b
$ [String]
v in
       if (Maybe Int -> Bool) -> [Maybe Int] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Maybe Int -> Bool
forall a. Maybe a -> Bool
isNothing [Maybe Int]
insV1
         then Maybe [Int]
forall a. Maybe a
Nothing
         else [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just ((Maybe Int -> Maybe Int) -> [Maybe Int] -> [Int]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Maybe Int -> Maybe Int
forall a. a -> a
id [Maybe Int]
insV1)
 | Bool
otherwise = Maybe [Int]
forall a. Maybe a
Nothing 

-- | Parses a 'String' being a list of Ints written with Haskell rules, e. g. \"[1..]\", \"[2,4..45]\", \"[3,5,6,7,8,3]\" etc. into a list of 'Int'.
-- If it is not possible or list is empty, returns []. Preceding whitespaces are ignored. An 'Int' argument is used as a delimiter to avoid infinite lists.
parseStoLInts :: Int -> String -> [Int]
parseStoLInts :: Int -> String -> [Int]
parseStoLInts Int
n String
xs
  | [String] -> Bool
canBePreParseV ([String] -> Bool) -> (String -> [String]) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
parseTup (String -> [String]) -> (String -> String) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isSpace (String -> Bool) -> String -> Bool
forall a b. (a -> b) -> a -> b
$ String
xs = [Int] -> Maybe [Int] -> [Int]
forall a. a -> Maybe a -> a
fromMaybe [] (Int -> [String] -> Maybe [Int]
parseV Int
n (String -> [String]
parseTup (String -> [String]) -> (String -> String) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isSpace (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ String
xs))
  | Bool
otherwise = []