-- Copyright 2016 Evan Laforge
-- This program is distributed under the terms of the GNU General Public
-- License 3.0, see COPYING or http://www.gnu.org/licenses/gpl-3.0.txt

{-# LANGUAGE RecordWildCards #-}
{- | This is analogous to "Solkattu.Dsl.Solkattu", except it exports
    a mridangam-specific notation without using sollus at all.

    Its sollu type is just 'Mridangam.Stroke', so it doesn't need a StrokeMap.
-}
module Solkattu.Dsl.Mridangam (
    module Solkattu.Dsl.Mridangam
    , module Dsl.Solkattu
    , module Solkattu.Dsl.Generic
    , module Solkattu.Dsl.Interactive
) where
import           Prelude hiding ((.))

import qualified Util.CallStack as CallStack
import           Solkattu.Dsl.Interactive (diff, diffw)
import qualified Solkattu.Dsl.MridangamNotation as MridangamNotation
import qualified Solkattu.Dsl.Solkattu as Dsl.Solkattu
import           Solkattu.Dsl.Solkattu (realizeScore, realizeScoreM)
import qualified Solkattu.Format.Terminal as Terminal
import qualified Solkattu.Instrument.Mridangam as Mridangam
import qualified Solkattu.Korvai as Korvai
import qualified Solkattu.Realize as Realize
import qualified Solkattu.S as S
import qualified Solkattu.Solkattu as Solkattu
import qualified Solkattu.Tala as Tala

import           Global
import           Solkattu.Dsl.Generic


type Sequence = SequenceT Stroke
type Stroke = Realize.Stroke Mridangam.Stroke
type Section = Korvai.Section Sequence

-- | Merge a sequence of left hand strokes with one of right hand strokes.
-- Both sequences must have the same length and structure.
(&) :: CallStack.Stack => Sequence -> Sequence -> Sequence
Sequence
a & :: Stack => Sequence -> Sequence -> Sequence
& Sequence
b = [Note Group (Note Stroke)] -> Sequence
forall g a. [Note g a] -> Sequence g a
S.fromList ([Note Group (Note Stroke)] -> Sequence)
-> [Note Group (Note Stroke)] -> Sequence
forall a b. (a -> b) -> a -> b
$ Stack =>
[Note Group (Note Stroke)]
-> [Note Group (Note Stroke)] -> [Note Group (Note Stroke)]
[Note Group (Note Stroke)]
-> [Note Group (Note Stroke)] -> [Note Group (Note Stroke)]
MridangamNotation.merge (Sequence -> [Note Group (Note Stroke)]
forall g a. Sequence g a -> [Note g a]
S.toList Sequence
a) (Sequence -> [Note Group (Note Stroke)]
forall g a. Sequence g a -> [Note g a]
S.toList Sequence
b)

korvai :: Tala.Tala -> [Section] -> Korvai.Korvai
korvai :: Tala -> [Section] -> Korvai
korvai Tala
tala = Tala -> PatternMap Stroke -> [Section] -> Korvai
Korvai.mridangamKorvai Tala
tala PatternMap Stroke
Mridangam.defaultPatterns

korvai1 :: Tala.Tala -> Section -> Korvai.Korvai
korvai1 :: Tala -> Section -> Korvai
korvai1 Tala
tala Section
section = Tala -> [Section] -> Korvai
korvai Tala
tala [Section
section]

-- | Infer Section types, as init is development, last is ending.
korvaiS :: Tala.Tala -> [Sequence] -> Korvai.Korvai
korvaiS :: Tala -> [Sequence] -> Korvai
korvaiS Tala
tala = Tala -> [Section] -> Korvai
korvai Tala
tala ([Section] -> Korvai)
-> ([Sequence] -> [Section]) -> [Sequence] -> Korvai
forall b c a. (b -> c) -> (a -> b) -> a -> c
 [Sequence] -> [Section]
forall sollu. [SequenceT sollu] -> [Section (SequenceT sollu)]
Korvai.inferSections

korvaiS1 :: Tala.Tala -> Sequence -> Korvai.Korvai
korvaiS1 :: Tala -> Sequence -> Korvai
korvaiS1 Tala
tala Sequence
sequence = Tala -> [Sequence] -> Korvai
korvaiS Tala
tala [Sequence
sequence]

Mridangam.Strokes {Sequence g (Note Stroke)
od :: Sequence g (Note Stroke)
_' :: Sequence g (Note Stroke)
o' :: Sequence g (Note Stroke)
o :: Sequence g (Note Stroke)
p' :: Sequence g (Note Stroke)
p :: Sequence g (Note Stroke)
j :: Sequence g (Note Stroke)
y :: Sequence g (Note Stroke)
i :: Sequence g (Note Stroke)
v :: Sequence g (Note Stroke)
u :: Sequence g (Note Stroke)
d :: Sequence g (Note Stroke)
n :: Sequence g (Note Stroke)
l :: Sequence g (Note Stroke)
t :: Sequence g (Note Stroke)
k :: Sequence g (Note Stroke)
od :: forall a. Strokes a -> a
_' :: forall a. Strokes a -> a
o' :: forall a. Strokes a -> a
o :: forall a. Strokes a -> a
p' :: forall a. Strokes a -> a
p :: forall a. Strokes a -> a
j :: forall a. Strokes a -> a
y :: forall a. Strokes a -> a
i :: forall a. Strokes a -> a
v :: forall a. Strokes a -> a
u :: forall a. Strokes a -> a
d :: forall a. Strokes a -> a
n :: forall a. Strokes a -> a
l :: forall a. Strokes a -> a
t :: forall a. Strokes a -> a
k :: forall a. Strokes a -> a
..} = Strokes (Sequence g (Note Stroke))
forall g. Strokes (Sequence g (Note Stroke))
Mridangam.notes

-- * interactive utilities

realize, realizep :: Korvai.Korvai -> IO ()
realize :: Korvai -> IO ()
realize = (Config -> Config) -> Korvai -> IO ()
realizeM Config -> Config
forall a. a -> a
id
realizep :: Korvai -> IO ()
realizep = (Config -> Config) -> Korvai -> IO ()
realizeM Config -> Config
concrete

realizeM :: (Terminal.Config -> Terminal.Config) -> Korvai.Korvai -> IO ()
realizeM :: (Config -> Config) -> Korvai -> IO ()
realizeM = (Stroke -> Maybe Stroke)
-> Instrument Stroke -> (Config -> Config) -> Korvai -> IO ()
forall stroke1 stroke2.
(Notation stroke1, Notation stroke2, Ord stroke1) =>
(Stroke stroke1 -> Maybe (Stroke stroke2))
-> Instrument stroke1 -> (Config -> Config) -> Korvai -> IO ()
Dsl.Solkattu._printInstrument Stroke -> Maybe Stroke
forall a. a -> Maybe a
Just Instrument Stroke
Korvai.IMridangam

-- * strokes

on :: Sequence
on :: Sequence
on = Sequence
forall {g}. Sequence g (Note Stroke)
oStack => Sequence -> Sequence -> Sequence
Sequence -> Sequence -> Sequence
&Sequence
forall {g}. Sequence g (Note Stroke)
n

p_, pp :: Sequence
p_ :: Sequence
p_ = Sequence -> Sequence
forall stroke.
SequenceT (Stroke stroke) -> SequenceT (Stroke stroke)
lt Sequence
forall {g}. Sequence g (Note Stroke)
p
pp :: Sequence
pp = Sequence -> Sequence
forall stroke.
SequenceT (Stroke stroke) -> SequenceT (Stroke stroke)
hv Sequence
forall {g}. Sequence g (Note Stroke)
p

-- | Thom -> tha.  This converts even Both strokes.
closedAll :: Sequence -> Sequence
closedAll :: Sequence -> Sequence
closedAll = (Stroke -> Maybe Stroke) -> Sequence -> Sequence
mapMStroke ((Stroke -> Maybe Stroke) -> Sequence -> Sequence)
-> (Stroke -> Maybe Stroke) -> Sequence -> Sequence
forall a b. (a -> b) -> a -> b
$ \case
    Mridangam.Thoppi (Mridangam.Thom Thom
_) ->
        Stroke -> Maybe Stroke
forall a. a -> Maybe a
Just (Stroke -> Maybe Stroke) -> Stroke -> Maybe Stroke
forall a b. (a -> b) -> a -> b
$ Thoppi -> Stroke
Mridangam.Thoppi (Tha -> Thoppi
Mridangam.Tha Tha
Mridangam.Palm)
    Mridangam.Both (Mridangam.Thom Thom
_) Valantalai
a ->
        Stroke -> Maybe Stroke
forall a. a -> Maybe a
Just (Stroke -> Maybe Stroke) -> Stroke -> Maybe Stroke
forall a b. (a -> b) -> a -> b
$ Thoppi -> Valantalai -> Stroke
Mridangam.Both (Tha -> Thoppi
Mridangam.Tha Tha
Mridangam.Palm) Valantalai
a
    Stroke
s -> Stroke -> Maybe Stroke
forall a. a -> Maybe a
Just Stroke
s

closed :: Sequence -> Sequence
closed :: Sequence -> Sequence
closed = (Stroke -> Maybe Stroke) -> Sequence -> Sequence
mapMStroke ((Stroke -> Maybe Stroke) -> Sequence -> Sequence)
-> (Stroke -> Maybe Stroke) -> Sequence -> Sequence
forall a b. (a -> b) -> a -> b
$ \case
    Mridangam.Thoppi (Mridangam.Thom Thom
_) ->
        Stroke -> Maybe Stroke
forall a. a -> Maybe a
Just (Stroke -> Maybe Stroke) -> Stroke -> Maybe Stroke
forall a b. (a -> b) -> a -> b
$ Thoppi -> Stroke
Mridangam.Thoppi (Tha -> Thoppi
Mridangam.Tha Tha
Mridangam.Palm)
    Mridangam.Both (Mridangam.Thom Thom
_) Valantalai
a ->
        Stroke -> Maybe Stroke
forall a. a -> Maybe a
Just (Stroke -> Maybe Stroke) -> Stroke -> Maybe Stroke
forall a b. (a -> b) -> a -> b
$ Valantalai -> Stroke
Mridangam.Valantalai Valantalai
a
    Stroke
s -> Stroke -> Maybe Stroke
forall a. a -> Maybe a
Just Stroke
s

noThom :: Sequence -> Sequence
noThom :: Sequence -> Sequence
noThom = (Stroke -> Maybe Stroke) -> Sequence -> Sequence
mapMStroke ((Stroke -> Maybe Stroke) -> Sequence -> Sequence)
-> (Stroke -> Maybe Stroke) -> Sequence -> Sequence
forall a b. (a -> b) -> a -> b
$ \case
    Mridangam.Thoppi (Mridangam.Thom Thom
_) -> Maybe Stroke
forall a. Maybe a
Nothing
    Mridangam.Both (Mridangam.Thom Thom
_) Valantalai
a -> Stroke -> Maybe Stroke
forall a. a -> Maybe a
Just (Stroke -> Maybe Stroke) -> Stroke -> Maybe Stroke
forall a b. (a -> b) -> a -> b
$ Valantalai -> Stroke
Mridangam.Valantalai Valantalai
a
    Stroke
s -> Stroke -> Maybe Stroke
forall a. a -> Maybe a
Just Stroke
s

thomLH :: Sequence -> Sequence
thomLH :: Sequence -> Sequence
thomLH = (Note Stroke -> Note Stroke) -> Sequence -> Sequence
mapNote ((Note Stroke -> Note Stroke) -> Sequence -> Sequence)
-> (Note Stroke -> Note Stroke) -> Sequence -> Sequence
forall a b. (a -> b) -> a -> b
$ \Note Stroke
note -> if Note Stroke
note Note Stroke -> [Note Stroke] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Note Stroke
n, Note Stroke
d] then Note Stroke
o else Note Stroke
forall a. Rest a => a
__
    where
    Mridangam.Strokes {Note Stroke
od :: Note Stroke
_' :: Note Stroke
o' :: Note Stroke
p' :: Note Stroke
p :: Note Stroke
j :: Note Stroke
y :: Note Stroke
i :: Note Stroke
v :: Note Stroke
u :: Note Stroke
l :: Note Stroke
t :: Note Stroke
k :: Note Stroke
o :: Note Stroke
d :: Note Stroke
n :: Note Stroke
od :: forall a. Strokes a -> a
_' :: forall a. Strokes a -> a
o' :: forall a. Strokes a -> a
o :: forall a. Strokes a -> a
p' :: forall a. Strokes a -> a
p :: forall a. Strokes a -> a
j :: forall a. Strokes a -> a
y :: forall a. Strokes a -> a
i :: forall a. Strokes a -> a
v :: forall a. Strokes a -> a
u :: forall a. Strokes a -> a
d :: forall a. Strokes a -> a
n :: forall a. Strokes a -> a
l :: forall a. Strokes a -> a
t :: forall a. Strokes a -> a
k :: forall a. Strokes a -> a
..} = NoteT Stroke -> Note Stroke
forall sollu. NoteT sollu -> Note sollu
Solkattu.Note (NoteT Stroke -> Note Stroke)
-> (Stroke -> NoteT Stroke) -> Stroke -> Note Stroke
forall b c a. (b -> c) -> (a -> b) -> a -> c
 Stroke -> NoteT Stroke
forall sollu. sollu -> NoteT sollu
Solkattu.note (Stroke -> NoteT Stroke)
-> (Stroke -> Stroke) -> Stroke -> NoteT Stroke
forall b c a. (b -> c) -> (a -> b) -> a -> c
 Stroke -> Stroke
forall stroke. stroke -> Stroke stroke
Realize.stroke (Stroke -> Note Stroke) -> Strokes Stroke -> Strokes (Note Stroke)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Strokes Stroke
Mridangam.strokes

-- | Add a 'o' to the first stroke.
o1 :: Sequence -> Sequence
o1 :: Sequence -> Sequence
o1 = (Note Group (Note Stroke) -> Note Group (Note Stroke))
-> Sequence -> Sequence
forall {g} {a}.
(Note g a -> Note g a) -> Sequence g a -> Sequence g a
maph ((Note Group (Note Stroke) -> Note Group (Note Stroke))
 -> Sequence -> Sequence)
-> (Note Group (Note Stroke) -> Note Group (Note Stroke))
-> Sequence
-> Sequence
forall a b. (a -> b) -> a -> b
$ (Note Stroke -> Note Stroke)
-> Note Group (Note Stroke) -> Note Group (Note Stroke)
forall a g. (a -> a) -> Note g a -> Note g a
S.map1 ((Note Stroke -> Note Stroke)
 -> Note Group (Note Stroke) -> Note Group (Note Stroke))
-> (Note Stroke -> Note Stroke)
-> Note Group (Note Stroke)
-> Note Group (Note Stroke)
forall a b. (a -> b) -> a -> b
$ (Stroke -> Stroke) -> Note Stroke -> Note Stroke
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Stroke -> Stroke) -> Note Stroke -> Note Stroke)
-> (Stroke -> Stroke) -> Note Stroke -> Note Stroke
forall a b. (a -> b) -> a -> b
$ (Stroke -> Stroke) -> Stroke -> Stroke
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Stroke -> Stroke) -> Stroke -> Stroke)
-> (Stroke -> Stroke) -> Stroke -> Stroke
forall a b. (a -> b) -> a -> b
$
    Thoppi -> Stroke -> Stroke
Mridangam.addThoppi (Thom -> Thoppi
Mridangam.Thom Thom
Mridangam.Low)
    where
    maph :: (Note g a -> Note g a) -> Sequence g a -> Sequence g a
maph Note g a -> Note g a
f Sequence g a
seq = case Sequence g a -> [Note g a]
forall g a. Sequence g a -> [Note g a]
S.toList Sequence g a
seq of
        Note g a
n : [Note g a]
ns -> [Note g a] -> Sequence g a
forall g a. [Note g a] -> Sequence g a
S.fromList ([Note g a] -> Sequence g a) -> [Note g a] -> Sequence g a
forall a b. (a -> b) -> a -> b
$ Note g a -> Note g a
f Note g a
n Note g a -> [Note g a] -> [Note g a]
forall a. a -> [a] -> [a]
: [Note g a]
ns
        [] -> Sequence g a
forall a. Monoid a => a
mempty

mapMStroke :: (Mridangam.Stroke -> Maybe Mridangam.Stroke) -> Sequence
    -> Sequence
mapMStroke :: (Stroke -> Maybe Stroke) -> Sequence -> Sequence
mapMStroke Stroke -> Maybe Stroke
f = (Note Stroke -> Note Stroke) -> Sequence -> Sequence
mapNote ((Note Stroke -> Note Stroke) -> Sequence -> Sequence)
-> (Note Stroke -> Note Stroke) -> Sequence -> Sequence
forall a b. (a -> b) -> a -> b
$ \case
    Solkattu.Note NoteT Stroke
n -> case (Stroke -> Maybe Stroke) -> Stroke -> Maybe Stroke
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Stroke -> Maybe Stroke
f (NoteT Stroke -> Stroke
forall sollu. NoteT sollu -> sollu
Solkattu._sollu NoteT Stroke
n) of
        Maybe Stroke
Nothing -> Space -> Note Stroke
forall sollu. Space -> Note sollu
Solkattu.Space Space
Solkattu.Rest
        Just Stroke
s -> NoteT Stroke -> Note Stroke
forall sollu. NoteT sollu -> Note sollu
Solkattu.Note (NoteT Stroke -> Note Stroke) -> NoteT Stroke -> Note Stroke
forall a b. (a -> b) -> a -> b
$ NoteT Stroke
n { _sollu :: Stroke
Solkattu._sollu = Stroke
s }
    Note Stroke
note -> Note Stroke
note

mapNote :: (Solkattu.Note Stroke -> Solkattu.Note Stroke)
    -> Sequence -> Sequence
mapNote :: (Note Stroke -> Note Stroke) -> Sequence -> Sequence
mapNote = (Note Stroke -> Note Stroke) -> Sequence -> Sequence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

-- | Parse a string to mridangam strokes.
strM :: CallStack.Stack => String -> Sequence
strM :: Stack => String -> Sequence
strM String
str = (Maybe Stroke -> Sequence) -> [Maybe Stroke] -> Sequence
forall b a. Monoid b => (a -> b) -> [a] -> b
mconcatMap Maybe Stroke -> Sequence
forall {g} {stroke}.
Rest (Sequence g (Note (Stroke stroke))) =>
Maybe stroke -> Sequence g (Note (Stroke stroke))
toSeq ([Maybe Stroke] -> Sequence) -> [Maybe Stroke] -> Sequence
forall a b. (a -> b) -> a -> b
$ Either Text [Maybe Stroke] -> [Maybe Stroke]
forall a. Stack => Either Text a -> a
Solkattu.check (Either Text [Maybe Stroke] -> [Maybe Stroke])
-> Either Text [Maybe Stroke] -> [Maybe Stroke]
forall a b. (a -> b) -> a -> b
$ String -> Either Text [Maybe Stroke]
Mridangam.fromString String
str
    where
    toSeq :: Maybe stroke -> Sequence g (Note (Stroke stroke))
toSeq Maybe stroke
Nothing = Sequence g (Note (Stroke stroke))
forall a. Rest a => a
__
    toSeq (Just stroke
stroke) = stroke -> Sequence g (Note (Stroke stroke))
forall stroke g. stroke -> Sequence g (Note (Stroke stroke))
Realize.strokeToSequence stroke
stroke

-- * fragments

-- | Taka and takatiku from solkattu.
kp, kpnp :: Sequence
kp :: Sequence
kp = Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
p
kpnp :: Sequence
kpnp = Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
pSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
nSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
p

ktkno :: Sequence
ktkno :: Sequence
ktkno = Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
tSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
nSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
o

kt, tk, ktkt :: Sequence
kt :: Sequence
kt = Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
t
tk :: Sequence
tk = Sequence
forall {g}. Sequence g (Note Stroke)
tSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
k
ktkt :: Sequence
ktkt = Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
tSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
t

ktpk :: Sequence
ktpk :: Sequence
ktpk = Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
tSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
pSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
k

ktok :: Sequence
ktok :: Sequence
ktok = Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
tSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
oSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
k

pk :: Sequence
pk :: Sequence
pk = Sequence
forall {g}. Sequence g (Note Stroke)
pSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
k

takadinna, kook :: Sequence
takadinna :: Sequence
takadinna = Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
oSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
oSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
k
kook :: Sequence
kook = Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
oSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
oSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
k

nakatiku :: Sequence
nakatiku :: Sequence
nakatiku = GroupType -> Text -> Sequence -> Sequence
forall sollu.
GroupType -> Text -> SequenceT sollu -> SequenceT sollu
namedT GroupType
Solkattu.GPattern Text
"8n" (Sequence
forall {g}. Sequence g (Note Stroke)
nSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
pSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
uSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
pSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
kSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
tSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
pSequence -> Sequence -> Sequence
forall a. Monoid a => a -> a -> a
.Sequence
forall {g}. Sequence g (Note Stroke)
k)
    -- also t.p.u.k.t.p.k