Karya, built on 2020-11-26T21:03:17 (patch 23b5be2d53a9e8e7d6136cda5aae2849abe5cded)
Safe HaskellNone

Solkattu.Realize

Description

Realize abstract solkattu S.Notes to concrete instrument-dependent Notes.

Synopsis

Documentation

type SNote stroke = S.Note () (Note stroke) Source #

The group is () because I don't need groups in the stroke map keys.

Note

data Note stroke Source #

The Solkattu.Sollus have been reduced to concrete strokes.

Constructors

Note !(Stroke stroke) 
Space !Solkattu.Space 
Abstract !Solkattu.Meta

A pattern that has been made abstract. This is a group that has been abstracted away. That means it can have a name, but also it doesn't have to have an integral matra duration. Since Abstract comes from Notes, the abstract duration is a series of 1-matra Abstracts, where each Note used to be.

These are created at the Format level, not here.

Alignment !Tala.Akshara

This is Solkattu.Alignment. It shouldn't be here, but since I now drop groups in realize via convertGroups, I have to do checkAlignment on the output of realize, which means I need to preserve the Alignments.

Instances

Instances details
Functor Note # 
Instance details

Defined in Solkattu.Realize

Methods

fmap :: (a -> b) -> Note a -> Note b #

(<$) :: a -> Note b -> Note a #

Foldable Note # 
Instance details

Defined in Solkattu.Realize

Methods

fold :: Monoid m => Note m -> m #

foldMap :: Monoid m => (a -> m) -> Note a -> m #

foldMap' :: Monoid m => (a -> m) -> Note a -> m #

foldr :: (a -> b -> b) -> b -> Note a -> b #

foldr' :: (a -> b -> b) -> b -> Note a -> b #

foldl :: (b -> a -> b) -> b -> Note a -> b #

foldl' :: (b -> a -> b) -> b -> Note a -> b #

foldr1 :: (a -> a -> a) -> Note a -> a #

foldl1 :: (a -> a -> a) -> Note a -> a #

toList :: Note a -> [a] #

null :: Note a -> Bool #

length :: Note a -> Int #

elem :: Eq a => a -> Note a -> Bool #

maximum :: Ord a => Note a -> a #

minimum :: Ord a => Note a -> a #

sum :: Num a => Note a -> a #

product :: Num a => Note a -> a #

Traversable Note # 
Instance details

Defined in Solkattu.Realize

Methods

traverse :: Applicative f => (a -> f b) -> Note a -> f (Note b) #

sequenceA :: Applicative f => Note (f a) -> f (Note a) #

mapM :: Monad m => (a -> m b) -> Note a -> m (Note b) #

sequence :: Monad m => Note (m a) -> m (Note a) #

Eq stroke => Eq (Note stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(==) :: Note stroke -> Note stroke -> Bool #

(/=) :: Note stroke -> Note stroke -> Bool #

Show stroke => Show (Note stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

showsPrec :: Int -> Note stroke -> ShowS #

show :: Note stroke -> String #

showList :: [Note stroke] -> ShowS #

DeepSeq.NFData (Note stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

rnf :: Note stroke -> () #

Pretty.Pretty stroke => Pretty.Pretty (Note stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

pretty :: Note stroke -> Text Source #

format :: Note stroke -> Doc Source #

formatList :: [Note stroke] -> Doc Source #

S.HasMatras (Note stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

matrasOf :: Note stroke -> S.Matra Source #

hasSustain :: Note stroke -> Bool Source #

Solkattu.Notation stroke => Solkattu.Notation (Note stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

notation :: Note stroke -> Text Source #

notationHtml :: Note stroke -> Doc.Html Source #

extension :: Note stroke -> Char.Char Source #

Rest (SNote sollu) # 
Instance details

Defined in Solkattu.Dsl.Notation

Methods

__ :: SNote sollu Source #

mapStroke :: Applicative f => (Stroke a -> f (Stroke b)) -> Note a -> f (Note b) Source #

data Stroke stroke Source #

Constructors

Stroke 

Fields

Instances

Instances details
Functor Stroke # 
Instance details

Defined in Solkattu.Realize

Methods

fmap :: (a -> b) -> Stroke a -> Stroke b #

(<$) :: a -> Stroke b -> Stroke a #

Foldable Stroke # 
Instance details

Defined in Solkattu.Realize

Methods

fold :: Monoid m => Stroke m -> m #

foldMap :: Monoid m => (a -> m) -> Stroke a -> m #

foldMap' :: Monoid m => (a -> m) -> Stroke a -> m #

foldr :: (a -> b -> b) -> b -> Stroke a -> b #

foldr' :: (a -> b -> b) -> b -> Stroke a -> b #

foldl :: (b -> a -> b) -> b -> Stroke a -> b #

foldl' :: (b -> a -> b) -> b -> Stroke a -> b #

foldr1 :: (a -> a -> a) -> Stroke a -> a #

foldl1 :: (a -> a -> a) -> Stroke a -> a #

toList :: Stroke a -> [a] #

null :: Stroke a -> Bool #

length :: Stroke a -> Int #

elem :: Eq a => a -> Stroke a -> Bool #

maximum :: Ord a => Stroke a -> a #

minimum :: Ord a => Stroke a -> a #

sum :: Num a => Stroke a -> a #

product :: Num a => Stroke a -> a #

Traversable Stroke # 
Instance details

Defined in Solkattu.Realize

Methods

traverse :: Applicative f => (a -> f b) -> Stroke a -> f (Stroke b) #

sequenceA :: Applicative f => Stroke (f a) -> f (Stroke a) #

mapM :: Monad m => (a -> m b) -> Stroke a -> m (Stroke b) #

sequence :: Monad m => Stroke (m a) -> m (Stroke a) #

Eq stroke => Eq (Stroke stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(==) :: Stroke stroke -> Stroke stroke -> Bool #

(/=) :: Stroke stroke -> Stroke stroke -> Bool #

Ord stroke => Ord (Stroke stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

compare :: Stroke stroke -> Stroke stroke -> Ordering #

(<) :: Stroke stroke -> Stroke stroke -> Bool #

(<=) :: Stroke stroke -> Stroke stroke -> Bool #

(>) :: Stroke stroke -> Stroke stroke -> Bool #

(>=) :: Stroke stroke -> Stroke stroke -> Bool #

max :: Stroke stroke -> Stroke stroke -> Stroke stroke #

min :: Stroke stroke -> Stroke stroke -> Stroke stroke #

Show stroke => Show (Stroke stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

showsPrec :: Int -> Stroke stroke -> ShowS #

show :: Stroke stroke -> String #

showList :: [Stroke stroke] -> ShowS #

Pretty.Pretty stroke => Pretty.Pretty (Stroke stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

pretty :: Stroke stroke -> Text Source #

format :: Stroke stroke -> Doc Source #

formatList :: [Stroke stroke] -> Doc Source #

Expr.ToExpr (Stroke Solkattu.Sollu) # 
Instance details

Defined in Solkattu.Instrument.Konnakol

Expr.ToExpr (Stroke Stroke) # 
Instance details

Defined in Solkattu.Instrument.Sargam

Expr.ToExpr (Stroke Stroke) # 
Instance details

Defined in Solkattu.Instrument.Reyong

Expr.ToExpr (Stroke Stroke) # 
Instance details

Defined in Solkattu.Instrument.Mridangam

Expr.ToExpr (Stroke Stroke) # 
Instance details

Defined in Solkattu.Instrument.KendangTunggal

Expr.ToExpr (Stroke Stroke) # 
Instance details

Defined in Solkattu.Instrument.KendangPasang

Solkattu.Notation stroke => Solkattu.Notation (Stroke stroke) # 
Instance details

Defined in Solkattu.Realize

stroke :: stroke -> Stroke stroke Source #

rest :: SNote stroke Source #

strokeToSequence :: stroke -> [S.Note g (Solkattu.Note (Stroke stroke))] Source #

data Emphasis Source #

The emphasis will be propagated to the underlying stroke.

Constructors

Light 
Normal 
Heavy 

Instances

Instances details
Eq Emphasis # 
Instance details

Defined in Solkattu.Realize

Ord Emphasis # 
Instance details

Defined in Solkattu.Realize

Show Emphasis # 
Instance details

Defined in Solkattu.Realize

Semigroup Emphasis # 
Instance details

Defined in Solkattu.Realize

Monoid Emphasis # 
Instance details

Defined in Solkattu.Realize

Pretty.Pretty Emphasis # 
Instance details

Defined in Solkattu.Realize

doubleRest :: Char.Char Source #

Used to replace two rests.

checkAlignment

data Warning Source #

Stroke index and warning text.

Constructors

Warning (Maybe.Maybe Int) !Text 

Instances

Instances details
Eq Warning # 
Instance details

Defined in Solkattu.Realize

Methods

(==) :: Warning -> Warning -> Bool #

(/=) :: Warning -> Warning -> Bool #

Show Warning # 
Instance details

Defined in Solkattu.Realize

checkAlignment :: Tala.Tala -> S.Duration -> S.Duration -> [(S.Tempo, Note stroke)] -> Maybe.Maybe Warning Source #

Verify that the notes start and end at sam, and the given Alignments fall where expected.

checkDuration :: [Realized stroke] -> ([Realized stroke], [Warning]) Source #

Check Solkattu.GCheckDuration, and filter them out.

flatDuration :: [Realized stroke] -> S.Duration Source #

Like Solkattu.flatDuration, but much simpler because for Realized I don't need the groups for duration.

StrokeMap

data StrokeMap stroke Source #

Sollu to instrument stroke mapping.

I considered integrating both strokes and patterns into SolluMap, but I kind of like how the types for SolluMap and PatternMap can be more specific. Namely, SolluMap has only strokes and rests, because it gets substituted for sollus, regardless of their rhythm, while PatternMap can have tempo changes since they always substitute a single Solkattu.Note. If I ever have a use for e.g. (taka.p5, ...) then I could reconsider.

Constructors

StrokeMap 

Fields

Instances

Instances details
Eq stroke => Eq (StrokeMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(==) :: StrokeMap stroke -> StrokeMap stroke -> Bool #

(/=) :: StrokeMap stroke -> StrokeMap stroke -> Bool #

Show stroke => Show (StrokeMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

showsPrec :: Int -> StrokeMap stroke -> ShowS #

show :: StrokeMap stroke -> String #

showList :: [StrokeMap stroke] -> ShowS #

Generics.Generic (StrokeMap stroke) # 
Instance details

Defined in Solkattu.Realize

Associated Types

type Generics.Rep (StrokeMap stroke) :: Type -> Type #

Methods

from :: StrokeMap stroke -> Generics.Rep (StrokeMap stroke) x #

to :: Generics.Rep (StrokeMap stroke) x -> StrokeMap stroke #

Semigroup (StrokeMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(<>) :: StrokeMap stroke -> StrokeMap stroke -> StrokeMap stroke #

sconcat :: NonEmpty (StrokeMap stroke) -> StrokeMap stroke #

stimes :: Integral b => b -> StrokeMap stroke -> StrokeMap stroke #

Monoid (StrokeMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

mempty :: StrokeMap stroke #

mappend :: StrokeMap stroke -> StrokeMap stroke -> StrokeMap stroke #

mconcat :: [StrokeMap stroke] -> StrokeMap stroke #

Pretty.Pretty stroke => Pretty.Pretty (StrokeMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

pretty :: StrokeMap stroke -> Text Source #

format :: StrokeMap stroke -> Doc Source #

formatList :: [StrokeMap stroke] -> Doc Source #

type Generics.Rep (StrokeMap stroke) # 
Instance details

Defined in Solkattu.Realize

strokeMap :: Pretty.Pretty stroke => PatternMap stroke -> [([S.Note g (Solkattu.Note Solkattu.Sollu)], [S.Note g (Solkattu.Note (Stroke stroke))])] -> Either Error (StrokeMap stroke) Source #

Verify a list of pairs stroke map and put them in an StrokeMap.

solkattuToRealize :: [S.Note g (Solkattu.Note (Stroke stroke))] -> Either Error [S.Note () (Note stroke)] Source #

Stroke maps use Notes, so they can use the same language in Solkattu.Dsl. But since they don't go through a realization step (being used to implement the realization step for sollus), I can directly map them to Notes before storing them in StrokeMap.

PatternMap

newtype PatternMap stroke Source #

This maps a Pattern of a certain duration to a realization. The S.Matras should the same duration as the the list in the default tempo. This is enforced in the constructor patternMap.

Constructors

PatternMap (Map Solkattu.Pattern [SNote stroke]) 

Instances

Instances details
Eq stroke => Eq (PatternMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(==) :: PatternMap stroke -> PatternMap stroke -> Bool #

(/=) :: PatternMap stroke -> PatternMap stroke -> Bool #

Show stroke => Show (PatternMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

showsPrec :: Int -> PatternMap stroke -> ShowS #

show :: PatternMap stroke -> String #

showList :: [PatternMap stroke] -> ShowS #

Semigroup (PatternMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(<>) :: PatternMap stroke -> PatternMap stroke -> PatternMap stroke #

sconcat :: NonEmpty (PatternMap stroke) -> PatternMap stroke #

stimes :: Integral b => b -> PatternMap stroke -> PatternMap stroke #

Monoid (PatternMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

mempty :: PatternMap stroke #

mappend :: PatternMap stroke -> PatternMap stroke -> PatternMap stroke #

mconcat :: [PatternMap stroke] -> PatternMap stroke #

Pretty.Pretty stroke => Pretty.Pretty (PatternMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

pretty :: PatternMap stroke -> Text Source #

format :: PatternMap stroke -> Doc Source #

formatList :: [PatternMap stroke] -> Doc Source #

patternMap :: [(Solkattu.Pattern, [SNote stroke])] -> Either Error (PatternMap stroke) Source #

Make a PatternMap while checking that the durations match. Analogous to solluMap.

SolluMap

newtype SolluMap stroke Source #

Sollus and Strokes should be the same length. This is enforced in the constructor solluMap. Nothing is a rest, which means a sollu can map to silence, which actually happens in practice.

Instances

Instances details
Eq stroke => Eq (SolluMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(==) :: SolluMap stroke -> SolluMap stroke -> Bool #

(/=) :: SolluMap stroke -> SolluMap stroke -> Bool #

Show stroke => Show (SolluMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

showsPrec :: Int -> SolluMap stroke -> ShowS #

show :: SolluMap stroke -> String #

showList :: [SolluMap stroke] -> ShowS #

Semigroup (SolluMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(<>) :: SolluMap stroke -> SolluMap stroke -> SolluMap stroke #

sconcat :: NonEmpty (SolluMap stroke) -> SolluMap stroke #

stimes :: Integral b => b -> SolluMap stroke -> SolluMap stroke #

Monoid (SolluMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

mempty :: SolluMap stroke #

mappend :: SolluMap stroke -> SolluMap stroke -> SolluMap stroke #

mconcat :: [SolluMap stroke] -> SolluMap stroke #

Pretty.Pretty stroke => Pretty.Pretty (SolluMap stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

pretty :: SolluMap stroke -> Text Source #

format :: SolluMap stroke -> Doc Source #

formatList :: [SolluMap stroke] -> Doc Source #

type SolluMapKey sollu = (Maybe.Maybe Solkattu.Tag, [sollu]) Source #

simpleSolluMap :: [([Solkattu.Sollu], [Maybe.Maybe stroke])] -> SolluMap stroke Source #

Directly construct a SolluMap from strokes.

solluMap :: Pretty.Pretty stroke => [([S.Note g (Solkattu.Note Solkattu.Sollu)], [SNote stroke])] -> Either Error (SolluMap stroke, [(SolluMapKey Solkattu.Sollu, [Maybe.Maybe (Stroke stroke)])]) Source #

Verify and costruct a SolluMap from a list of pairs. Later pairs win over earlier ones.

verifySolluMap :: Pretty.Pretty stroke => ([S.Note g (Solkattu.Note Solkattu.Sollu)], [SNote stroke]) -> Either Error (SolluMapKey Solkattu.Sollu, [Maybe.Maybe (Stroke stroke)]) Source #

A sollu can map to a rest stroke: tang.ga, where ga is silent Or taka.tarikita played N_ktpk. But I don't think a rest sollu can map to a stroke, and in fact it won't work since I look up by sollus only.

zipTails :: [a] -> [b] -> [([a], [b])] Source #

realize

type RealizePattern tempo stroke = tempo -> Solkattu.Pattern -> Either Error [(tempo, Note stroke)] Source #

data Group stroke Source #

This is the realized version of Solkattu.Group. I retain the dropped strokes so Solkattu.Technique can use them.

Constructors

GReduction !(Reduction stroke) 
GMeta !Solkattu.Meta 

Instances

Instances details
Functor Group # 
Instance details

Defined in Solkattu.Realize

Methods

fmap :: (a -> b) -> Group a -> Group b #

(<$) :: a -> Group b -> Group a #

Eq stroke => Eq (Group stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(==) :: Group stroke -> Group stroke -> Bool #

(/=) :: Group stroke -> Group stroke -> Bool #

Ord stroke => Ord (Group stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

compare :: Group stroke -> Group stroke -> Ordering #

(<) :: Group stroke -> Group stroke -> Bool #

(<=) :: Group stroke -> Group stroke -> Bool #

(>) :: Group stroke -> Group stroke -> Bool #

(>=) :: Group stroke -> Group stroke -> Bool #

max :: Group stroke -> Group stroke -> Group stroke #

min :: Group stroke -> Group stroke -> Group stroke #

Show stroke => Show (Group stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

showsPrec :: Int -> Group stroke -> ShowS #

show :: Group stroke -> String #

showList :: [Group stroke] -> ShowS #

Pretty.Pretty stroke => Pretty.Pretty (Group stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

pretty :: Group stroke -> Text Source #

format :: Group stroke -> Doc Source #

formatList :: [Group stroke] -> Doc Source #

data Reduction stroke Source #

Constructors

Reduction 

Fields

Instances

Instances details
Functor Reduction # 
Instance details

Defined in Solkattu.Realize

Methods

fmap :: (a -> b) -> Reduction a -> Reduction b #

(<$) :: a -> Reduction b -> Reduction a #

Eq stroke => Eq (Reduction stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

(==) :: Reduction stroke -> Reduction stroke -> Bool #

(/=) :: Reduction stroke -> Reduction stroke -> Bool #

Ord stroke => Ord (Reduction stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

compare :: Reduction stroke -> Reduction stroke -> Ordering #

(<) :: Reduction stroke -> Reduction stroke -> Bool #

(<=) :: Reduction stroke -> Reduction stroke -> Bool #

(>) :: Reduction stroke -> Reduction stroke -> Bool #

(>=) :: Reduction stroke -> Reduction stroke -> Bool #

max :: Reduction stroke -> Reduction stroke -> Reduction stroke #

min :: Reduction stroke -> Reduction stroke -> Reduction stroke #

Show stroke => Show (Reduction stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

showsPrec :: Int -> Reduction stroke -> ShowS #

show :: Reduction stroke -> String #

showList :: [Reduction stroke] -> ShowS #

Pretty.Pretty stroke => Pretty.Pretty (Reduction stroke) # 
Instance details

Defined in Solkattu.Realize

Methods

pretty :: Reduction stroke -> Text Source #

format :: Reduction stroke -> Doc Source #

formatList :: [Reduction stroke] -> Doc Source #

type Realized stroke = S.Flat (Group (Stroke stroke)) (Note stroke) Source #

realize :: (Pretty.Pretty sollu, Ord sollu) => StrokeMap stroke -> ToStrokes sollu stroke -> Tala.Tala -> [S.Flat Solkattu.Group (Solkattu.Note sollu)] -> (UF.UntilFail Error (Realized stroke), Set (SolluMapKey sollu)) Source #

realize_ :: (Pretty.Pretty sollu, Ord sollu) => RealizePattern S.Tempo stroke -> ToStrokes sollu stroke -> Tala.Tala -> [S.Flat Solkattu.Group (Solkattu.Note sollu)] -> (UF.UntilFail Error (Realized stroke), Set (SolluMapKey sollu)) Source #

realizeSarva :: Pretty.Pretty sollu => ToStrokes sollu stroke -> Tala.Tala -> S.Tempo -> S.Matra -> [(S.State, S.Flat Solkattu.Group (Solkattu.Note sollu))] -> Either Error (SolluMapKey sollu, [S.Flat Solkattu.Group (Note stroke)]) Source #

Realize a Solkattu.GSarva group, by matching the sollus, and then cycling the strokes for the given duration.

convertGroups :: S.Flat Solkattu.Group (Note stroke) -> UF.UntilFail Error (S.Flat (Group (Stroke stroke)) (Note stroke)) Source #

Given a group like

[S.FGroup (Solkatttu.Reduction 1 Before) [a, b], c]

collect dropped strokes into a Realize.Reduction:

[S.FGroup (Reduction [a] Before) [b], c]

splitStrokes Source #

Arguments

:: S.Duration 
-> [S.Flat g (Note stroke)] 
-> Either Error (S.Duration, ([S.Flat g (Note stroke)], [S.Flat g (Note stroke)]))

(unusedDur, (pre, post))

makeSpace :: S.Tempo -> Solkattu.Space -> S.Duration -> Either Error [(S.Tempo, Note stroke)] Source #

Try to produce Spaces of the given Duration. Based on Notation.spaceD.

findSequence Source #

Arguments

:: Pretty.Pretty sollu 
=> ToStrokes sollu stroke 
-> [(state, S.Flat g (Solkattu.Note sollu))] 
-> Either Error (SolluMapKey sollu, ([(S.Tempo, Note stroke)], [(state, S.Flat g (Solkattu.Note sollu))]))

(matched, (strokes, remaining))

Find the longest matching sequence and return the match and unconsumed notes.

replaceSollus Source #

Arguments

:: [Maybe.Maybe (Stroke stroke)]

Nothing means a rest

-> [(state, S.Flat g (Solkattu.Note sollu))] 
-> ([(S.Tempo, Note stroke)], [(state, S.Flat g (Solkattu.Note sollu))]) 

Match each stroke to a Sollu, copying over Rests without consuming a stroke.

ToStrokes

data ToStrokes sollu stroke Source #

Find strokes for a sequence of sollus.

Constructors

ToStrokes 

Fields

realizeStroke :: ToStrokes (Stroke stroke) stroke Source #

If the sollu and stroke are the same, I can just copy the sollu. This is for "monomorphic" single instrument scores, such as for mridangam.

realizeSimpleStroke :: ToStrokes stroke stroke Source #

Like realizeStroke but without the Stroke wrapper.

bestMatch Source #

Arguments

:: Maybe.Maybe Solkattu.Tag 
-> [sollu] 
-> ToStrokes sollu stroke 
-> Maybe.Maybe (SolluMapKey sollu, [Maybe.Maybe (Stroke stroke)])

Nothing means no match, [Nothing] is a rest

Convert sollus to strokes.

text util