-- |
-- Module      :  DobutokO.Sound.ParseList
-- Copyright   :  (c) OleksandrZhabenko 2020, 2024
-- License     :  MIT
-- Stability   :  Experimental
-- Maintainer  :  oleksandr.zhabenko@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 DobutokO.Sound.ParseList where 

import Data.Char (isSpace)
import qualified Data.Vector as V
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. HasCallStack => [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. HasCallStack => [a] -> a
head (ReadS String
lex String
xs))

parseTupV :: String -> V.Vector String
parseTupV :: String -> Vector String
parseTupV = [String] -> Vector String
forall a. [a] -> Vector a
V.fromList ([String] -> Vector String)
-> (String -> [String]) -> String -> Vector String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
parseTup

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

containsExtV :: V.Vector String -> Bool
containsExtV :: Vector String -> Bool
containsExtV = String -> Vector String -> Bool
forall a. Eq a => a -> Vector a -> Bool
V.elem String
".."

-- | Predicate to check whether a 'V.Vector' 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 :: V.Vector String -> Bool
canBePreParseV :: Vector String -> Bool
canBePreParseV Vector String
v = Bool -> Bool
not (String -> Vector String -> Bool
forall a. Eq a => a -> Vector a -> Bool
V.elem String
"(" Vector String
v Bool -> Bool -> Bool
|| String -> Vector String -> Bool
forall a. Eq a => a -> Vector a -> Bool
V.elem String
"-" Vector String
v Bool -> Bool -> Bool
|| String -> Vector String -> Bool
forall a. Eq a => a -> Vector a -> Bool
V.elem String
")" Vector String
v)

-- | Notification. Uses an 'Int' limitation to avoid infinite lists. All arguments must be not negative.
parseV :: Int -> V.Vector String -> Maybe [Int]
parseV :: Int -> Vector String -> Maybe [Int]
parseV Int
n Vector String
v
 | Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
n Int
0 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT Bool -> Bool -> Bool
&& (String -> Bool) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") Vector String
v Vector Int -> Vector Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Vector Int
forall a. a -> Vector a
V.singleton Int
2 Bool -> Bool -> Bool
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
4 = 
    if Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
1)::Maybe Int in
        case Maybe Int
ins1 of
          Just Int
ins -> if Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
n Int
ins Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT 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 -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
n Int
0 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT Bool -> Bool -> Bool
&& (String -> Bool) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") Vector String
v Vector Int -> Vector Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Vector Int
forall a. a -> Vector a
V.singleton Int
2 Bool -> Bool -> Bool
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
5 =
    if Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
1)::Maybe Int 
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
n Int
0 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT Bool -> Bool -> Bool
&& (String -> Bool) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") Vector String
v Vector Int -> Vector Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Vector Int
forall a. a -> Vector a
V.singleton Int
4 Bool -> Bool -> Bool
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
6 =
    if Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
2 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"," Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
1)::Maybe Int 
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
n Int
0 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT Bool -> Bool -> Bool
&& (String -> Bool) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") Vector String
v Vector Int -> Vector Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Vector Int
forall a. a -> Vector a
V.singleton Int
4 Bool -> Bool -> Bool
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
7 =
    if Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
2 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"," Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
1)::Maybe Int 
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
3)::Maybe Int
               ins3 :: Maybe Int
ins3 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 a. [a] -> 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 -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
n Int
0 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v (Vector String -> Int
forall a. Vector a -> Int
V.length Vector 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
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector 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
&&
    (Vector Int -> [Int]
forall a. Vector a -> [a]
V.toList (Vector Int -> [Int])
-> (Vector String -> Vector Int) -> Vector String -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Bool) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
",") (Vector String -> [Int]) -> Vector String -> [Int]
forall a b. (a -> b) -> a -> b
$ Vector String
v) [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
2,Int
4..(Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
2)] =
      let insV1 :: Vector (Maybe Int)
insV1 = (Int -> String -> Maybe Int) -> Vector String -> Vector (Maybe Int)
forall a b. (Int -> a -> b) -> Vector a -> Vector b
V.imap (\Int
i String
_ -> String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v (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 -> Int -> Vector String -> Vector String
forall a. Int -> Int -> Vector a -> Vector a
V.unsafeSlice Int
0 (Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
2) Vector String
v) in
       if (Maybe Int -> Bool) -> Vector (Maybe Int) -> Bool
forall a. (a -> Bool) -> Vector a -> Bool
V.any Maybe Int -> Bool
forall a. Maybe a -> Bool
isNothing Vector (Maybe Int)
insV1
         then Maybe [Int]
forall a. Maybe a
Nothing
         else [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just (Vector Int -> [Int]
forall a. Vector a -> [a]
V.toList (Vector Int -> [Int])
-> (Vector (Maybe Int) -> Vector Int)
-> Vector (Maybe Int)
-> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Int -> Maybe Int) -> Vector (Maybe Int) -> Vector Int
forall a b. (a -> Maybe b) -> Vector a -> Vector b
V.mapMaybe Maybe Int -> Maybe Int
forall a. a -> a
id (Vector (Maybe Int) -> [Int]) -> Vector (Maybe Int) -> [Int]
forall a b. (a -> b) -> a -> b
$ Vector (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 :: V.Vector String -> Maybe [Int]
parseVInf :: Vector String -> Maybe [Int]
parseVInf Vector String
v
 | (String -> Bool) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") Vector String
v Vector Int -> Vector Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Vector Int
forall a. a -> Vector a
V.singleton Int
2 Bool -> Bool -> Bool
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
4 =
    if Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") Vector String
v Vector Int -> Vector Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Vector Int
forall a. a -> Vector a
V.singleton Int
2 Bool -> Bool -> Bool
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
5 =
    if Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
1)::Maybe Int
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") Vector String
v Vector Int -> Vector Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Vector Int
forall a. a -> Vector a
V.singleton Int
4 Bool -> Bool -> Bool
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
6 =
    if Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
2 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"," Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
1)::Maybe Int
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"..") Vector String
v Vector Int -> Vector Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Vector Int
forall a. a -> Vector a
V.singleton Int
4 Bool -> Bool -> Bool
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
7 =
    if Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
2 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"," Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
1)::Maybe Int
               ins2 :: Maybe Int
ins2 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
3)::Maybe Int
               ins3 :: Maybe Int
ins3 = String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v 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 a. [a] -> 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
 | Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v Int
0 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"[" Bool -> Bool -> Bool
&& Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v (Vector String -> Int
forall a. Vector a -> Int
V.length Vector 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
&& Vector String -> Int
forall a. Vector a -> Int
V.length Vector 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
&&
    (Vector Int -> [Int]
forall a. Vector a -> [a]
V.toList (Vector Int -> [Int])
-> (Vector String -> Vector Int) -> Vector String -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Bool) -> Vector String -> Vector Int
forall a. (a -> Bool) -> Vector a -> Vector Int
V.findIndices (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
",") (Vector String -> [Int]) -> Vector String -> [Int]
forall a b. (a -> b) -> a -> b
$ Vector String
v) [Int] -> [Int] -> Bool
forall a. Eq a => a -> a -> Bool
== [Int
2,Int
4..(Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
2)] =
      let insV1 :: Vector (Maybe Int)
insV1 = (Int -> String -> Maybe Int) -> Vector String -> Vector (Maybe Int)
forall a b. (Int -> a -> b) -> Vector a -> Vector b
V.imap (\Int
i String
_ -> String -> Maybe Int
forall a. Read a => String -> Maybe a
readMaybe (Vector String -> Int -> String
forall a. Vector a -> Int -> a
V.unsafeIndex Vector String
v (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 -> Int -> Vector String -> Vector String
forall a. Int -> Int -> Vector a -> Vector a
V.unsafeSlice Int
0 (Vector String -> Int
forall a. Vector a -> Int
V.length Vector String
v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
2) Vector String
v) in
       if (Maybe Int -> Bool) -> Vector (Maybe Int) -> Bool
forall a. (a -> Bool) -> Vector a -> Bool
V.any Maybe Int -> Bool
forall a. Maybe a -> Bool
isNothing Vector (Maybe Int)
insV1
         then Maybe [Int]
forall a. Maybe a
Nothing
         else [Int] -> Maybe [Int]
forall a. a -> Maybe a
Just (Vector Int -> [Int]
forall a. Vector a -> [a]
V.toList (Vector Int -> [Int])
-> (Vector (Maybe Int) -> Vector Int)
-> Vector (Maybe Int)
-> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Int -> Maybe Int) -> Vector (Maybe Int) -> Vector Int
forall a b. (a -> Maybe b) -> Vector a -> Vector b
V.mapMaybe Maybe Int -> Maybe Int
forall a. a -> a
id (Vector (Maybe Int) -> [Int]) -> Vector (Maybe Int) -> [Int]
forall a b. (a -> b) -> a -> b
$ Vector (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
  | Vector String -> Bool
canBePreParseV (Vector String -> Bool)
-> (String -> Vector String) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Vector String
parseTupV (String -> Vector String)
-> (String -> String) -> String -> Vector 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 -> Vector String -> Maybe [Int]
parseV Int
n (String -> Vector String
parseTupV (String -> Vector String)
-> (String -> String) -> String -> Vector 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 -> Vector String) -> String -> Vector String
forall a b. (a -> b) -> a -> b
$ String
xs))
  | Bool
otherwise = []