API References

AbstractRhythmicVisArgs

Abstract base type for rhythmic visualization arguments. Concrete subtypes define specific visualization configurations.

AbstractSyllable

Abstract base type for syllable representations used in rhythmic analysis.

Ayah Embeddings Type

params: numslices - number of slices varslices - variability of slices, parameter for Dirichlet distribution

Midpoints Generator

params: n_ayahs - total number of ayahs n - number of samples of slices to generate slicer - Slicer configuration

Harakaat(char::Union{String, Char}, is_tanween::Bool)

Create a Harakaat object using char as the Arabic orthography, which is expected to be the short vowels, sukūn, and tanween.

julia> fatha = arabic("a")
julia> Harakaat(fatha, false)
Harakaat("َ", false)

LastRecited <: AbstractRhythmicVisArgs

Configuration for last recited syllable visualization.

Fields

• variant::LastRecitedVariants: Specifies the visualization variant (A, B, or C) which determines how many subplots to create and what syllable components to display.

Examples

# Create with variant A (single subplot)
lr = LastRecited(A)

# Create with variant B (two subplots)
lr = LastRecited(B)

# Create with variant C (three subplots)
lr = LastRecited(C)

LastRecited()

Create a LastRecited object with default variant A (single subplot showing only the last syllable).

LastRecitedSyllable <: AbstractSyllable

Represents a syllable extracted from the end of a text in Buckwalter transliteration.

Fields

• syllable::Bw: The syllable in Buckwalter encoding

Examples

syllable = LastRecitedSyllable(Bw("mA"))

LastRecitedVariants

Enum specifying the variant of last-recited visualization.

Variants

• A: Single subplot showing only the last recited syllable
• B: Two subplots showing the syllable and the syllable with trailing consonant
• C: Three subplots showing the syllable, syllable with trailing consonant, and syllable with leading and trailing consonants

Rhythmic State

RhythmicVis(args::T) where T <: AbstractRhythmicVisArgs

Create a RhythmicVis object with the specified visualization type and arguments.

Arguments

• args::T: Visualization arguments, must be a subtype of AbstractRhythmicVisArgs

Examples

# Create a visualization with default LastRecited arguments
vis = RhythmicVis(LastRecited())

# Create with specific variant
vis = RhythmicVis(LastRecited(B))

(r::RhythmicVis)(texts::Vector{Bw}; fig_kwargs...)

Generate a rhythmic visualization from an array of Bw-encoded texts.

This is a functor/callable method for RhythmicVis objects that analyzes the last recited syllables in each text and creates a visualization showing how they vary across the texts.

Arguments

• texts::Vector{Bw}: Array of texts in Bw transliteration
• fig_kwargs...: Keyword arguments passed to the lines! plotting function (e.g., color, linewidth)

Returns

A tuple containing:

• Makie.Figure: The generated visualization figure
• Data tuple: A tuple of 1-3 data tuples (depending on variant), where each element contains:
  • Vector{Int64}: Y-axis numeric positions for each text
  • Dict{LastRecitedSyllable,Int64}: Dictionary mapping unique syllables to their assigned positions

The number of data tuples returned depends on the variant:

• Variant A: 1-tuple of data
• Variant B: 2-tuple of data
• Variant C: 3-tuple of data

Examples

# Single subplot visualization
vis = RhythmicVis(LastRecited(A))
fig, ((positions, syllable_map),) = vis(buckwalter_texts)

# Three subplot visualization
vis = RhythmicVis(LastRecited(C))
fig, (data1, data2, data3) = vis(buckwalter_texts, color=:blue)

Schillinger <: AbstractRhythmicVisArgs

A structure for visualizing rhythmic patterns using Joseph Schillinger's rhythmic graph theory.

Fields

• state_timings::Dict{Bw,RState}: A dictionary mapping Buckwalter-encoded vowel patterns to rhythmic states with their durations and descriptions.

Example

tajweed_timings = Dict{Bw,RState}(
    Bw("i") => RState(1, "short"),  # kasra
    Bw("a") => RState(1, "short"),  # fatha
    Bw("u") => RState(1, "short"),  # damma
    Bw("iy") => RState(2, "long"),  # kasra + yaa
    Bw("aA") => RState(2, "long"),  # fatha + alif
    Bw("uw") => RState(2, "long"),  # damma + waw
    Bw("^") => RState(4, "maddah")  # maddah
)

schillinger = Schillinger(tajweed_timings)

See also: rhythmic_states, vis

Segment(text::String, harakaat::Vector{Harakaat})

Create a Segment object from text, which is the form of the segments of syllables, where vowels of which are also listed as harakaat.

julia> bw_segment = Bw("~aH?Hiy")
julia> Segment(bw_segment, Harakaat[Harakaat(Bw("a"), false), Harakaat(Bw("i"), false)])
Segment("~aH?Hiy", Harakaat[Harakaat("a", false), Harakaat("i", false)])

Slicer Configuration

params: numslices - number of slices varslices - variability of slices, parameter for Dirichlet distribution dist_formula - distance metric for measuring similarity or distances of the slices

Rhyme(is_quran::Bool, syllable::Syllable)

Create a Rhyme object with specifics for the syllable contructed through Syllable. It also takes argument for is_quran to handle Qur'an input, which does not recite the last vowel in every last word of the verse. The following code creates a Syllable, which specifies 3 syllables with 1 leading and trailing characters to include.

julia> ar_raheem_alamiyn = ["ٱلرَّحِيمِ", "ٱلْعَٰلَمِينَ"]
2-element Vector{String}:
 "ٱلرَّحِيمِ"
 "ٱلْعَٰلَمِينَ"
julia> r = Syllabification(true, Syllable(1, 1, 3))
Rhyme(true, Syllable{Int64}(1, 1, 3))
julia> output = r.(ar_raheem_alamiyn, true)
2-element Vector{Segment}:
 Segment("َّح?حِي", Harakaat[Harakaat("َ", false), Harakaat("ِ", false)])
 Segment("عَٰ?لَم?مِي", Harakaat[Harakaat("َ", false), Harakaat("َ", false), Harakaat("ِ", false)])
julia> encode.(output)
2-element Vector{Segment}:
 Segment("~aH?Hiy", Harakaat[Harakaat("a", false), Harakaat("i", false)])
 Segment("Ea`?lam?miy", Harakaat[Harakaat("a", false), Harakaat("a", false), Harakaat("i", false)])

(r::Syllabification)(text::String, isarabic::Bool=false)

Call function for the Syllabification object. It extracts the rhyme features of text using the options from the Syllabification object specified by r. It can handle both Arabic and Buckwalter input by toggling isarabic.

Note: This will only work with @transliterator :default

julia> ar_raheem = "ٱلرَّحِيمِ"
"ٱلرَّحِيمِ"
julia> r = Syllabification(true, Syllable(1, 2, 1))
Syllabification(true, Syllable{Int64}(1, 2, 1))
julia> output = r(ar_raheem, true)
Segment("حِيم", Harakaat[Harakaat("ِ", false)])
julia> encode(output)
Segment("Hiym", Harakaat[Harakaat("i", false)])

Syllable{T <: Number}(
    lead_nchars::T,
    trail_nchars::T,
    nvowels::T
)

Create a Syllable object specifying the number of vowels nvowels to capture, and also the number of leading (lead_nchars) and trailing characters (trail_nchars) around the vowel. This object is used as an input for the Rhyme object. The following code creates a Syllable, which specifies 3 syllables with 1 leading and trailing characters to include.

julia> Syllable(1, 1, 3)
Syllable{Int64}(1, 1, 3)

align(src::String, tgt::String; costmodel::BioAlignments.CostModel=BioAlignments.CostModel(match=0, mismatch=1, insertion=1, deletion=1))

Align tgt string to src string using a particular costmodel from BioAlignments.jl.

align(src::Vector{String}, tgt::Vector{String};
	costmodel::CostModel=CostModel(match=0, mismatch=1, insertion=1, deletion=0),
	store_results::Bool=true
)

ALign tgt array of texts to src array of texts using a particular costmodel from BioAlignments.jl. store_results if results of alignment are stored or returned, otherwise, only the scores are returned.

arabic(s::String[, encoder::AbstractEncoder])

Encode the String object into Arabic characters. Custom encoder generated from @transliterator can be provided, but default is Buckwalter.

Examples

julia> bw_basmala = "bisomi {ll~ahi {lr~aHoma`ni {lr~aHiymi"
julia> arabic(bw_basmala)
"بِسْمِ ٱللَّهِ ٱلرَّحْمَٰنِ ٱلرَّحِيمِ"

clean(s::String, replace_non_ar::String, target_regex::Regex)

Clean the input text by replacing all non-Arabic texts with a string input.

Parent's Chromosome Crossover

The parents chromosome are crossed-over

dediac(s::String; isarabic::Bool=true)

Dediacritize the input String object.

Examples

julia> bw_basmala = "bisomi {ll~ahi {lr~aHoma`ni {lr~aHiymi"
julia> dediac(bw_basmala)
"bsm {llh {lrHmn {lrHym"
julia> dediac(arabic(bw_basmala))
"بسم ٱلله ٱلرحمن ٱلرحيم"

encode(s::Union{Char,String}, encoder::AbstractEncoder)

Transliterate the input String object using a custom encoder. Custom encoder is generated using the @transliterator.

encode(s::String)

Transliterate the input String object using Buckwalter.

Examples

julia> ar_basmala = "بِسْمِ ٱللَّهِ ٱلرَّحْمَٰنِ ٱلرَّحِيمِ"
julia> encode(ar_basmala)
"bisomi {ll~ahi {lr~aHoma`ni {lr~aHiymi"

Circular-wise Computation of the Distance of Slices

params: five_nums - five number summaries slicer - Slicer configuration dist - a Distances UnionSemiMetric

Compute Five Number Summary

five_summary(v::Vector{T}) where T<:Union{Float32,Float64} params: v - data (e.g. embeddings)

five_summary(slices::Vector{Vector{Matrix{T}}}) where T<:Union{Float32,Float64} params: slices - slices of data (e.g. ayah embeddings)

Slices Generator

params: ayahs_emb - the embeddings to slice midpoints - the midpoints used for slicing

isfeat(x::Orthography, y::Type{<:AbstractConsonant})

checks if x is a y feature.

julia> ar_basmala = "بِسْمِ ٱللَّهِ ٱلرَّحْمَٰنِ ٱلرَّحِيمِ";
julia> arb_token = tokenize(ar_basmala)
4-element Vector{String}:
 "بِسْمِ"
 "ٱللَّهِ"
 "ٱلرَّحْمَٰنِ"
 "ٱلرَّحِيمِ"
julia> arb_parsed2 = parse.(Orthography, arb_token)
4-element Vector{Orthography}:
 Orthography(Type[Ba, Kasra, Seen, Sukun, Meem, Kasra])
 Orthography(Type[AlifHamzatWasl, Lam, Lam, Shadda, Fatha, Ha, Kasra])
 Orthography(Type[AlifHamzatWasl, Lam, Ra, Shadda, Fatha, HHa, Sukun, Meem, Fatha, AlifKhanjareeya, Noon, Kasra])
 Orthography(Type[AlifHamzatWasl, Lam, Ra, Shadda, Fatha, HHa, Kasra, Ya, Meem, Kasra])
julia> isfeat(arb_parsed2[1], AbstractLunar)
6-element BitVector:
 1
 0
 0
 0
 1
 0

last_syllable(lr::LastRecited, text::Bw)

Extract the last syllable(s) from Buckwalter-encoded text according to the specified variant.

The function extracts different representations of the final syllable based on the variant:

• Variant A: Returns 1-tuple with just the last syllable (2 characters from end, positions end-3:end-2)
• Variant B: Returns 2-tuple with the syllable and syllable+trailing consonant (positions end-3:end-1)
• Variant C: Returns 3-tuple with syllable, syllable+trailing, and leading+syllable+trailing (positions end-4:end-1)

Arguments

• lr::LastRecited: Configuration specifying which variant to use
• text::Bw: The Buckwalter-encoded text to extract from

Returns

A tuple of LastRecitedSyllable objects (1, 2, or 3 elements depending on variant)

Examples

text = Bw("...mAno")
lr = LastRecited(A)
(syl,) = last_syllable(lr, text)  # Returns 1-tuple

lr = LastRecited(C)
(syl, syl_trailing, full) = last_syllable(lr, text)  # Returns 3-tuple

normalize(s::String)

Normalize a Arabic or Buckwalter String characters.

Examples

julia> normalize("بِسْمِ ٱللَّهِ ٱلرَّحْمَٰنِ ٱلرَّحِيمِ")
"بِسْمِ اللَّهِ الرَّحْمَانِ الرَّحِيمِ"

normalize(s::String, char::Symbol; isarabic::Bool=true)

Normalize a specific Arabic or Buckwalter String character (chars).

Examples

julia> ar_basmala = "بِسْمِ ٱللَّهِ ٱلرَّحْمَٰنِ ٱلرَّحِيمِ"
julia> normalize(ar_basmala, :alif_khanjareeya) === "بِسْمِ ٱللَّهِ ٱلرَّحْمَانِ ٱلرَّحِيمِ"

normalize(s::String, chars::Vector{Symbol}; isarabic::Bool=true)

Normalize a specific Arabic or Buckwalter String character/s (chars).

Examples

julia> ar_basmala = "بِسْمِ ٱللَّهِ ٱلرَّحْمَٰنِ ٱلرَّحِيمِ"
julia> normalize(ar_basmala, [:alif_khanjareeya, :hamzat_wasl]) === "بِسْمِ اللَّهِ الرَّحْمَانِ الرَّحِيمِ"

rhythmic_states(data::Schillinger, texts::Vector{Bw}) -> Vector{Vector{RState}}

Analyzes Buckwalter-encoded Arabic texts and converts them into rhythmic states based on Schillinger's rhythmic theory.

Arguments

• data::Schillinger: A Schillinger object containing the mapping of vowel patterns to rhythmic states.
• texts::Vector{Bw}: A vector of Buckwalter-encoded Arabic text strings to analyze.

Returns

• Vector{Vector{RState}}: A vector where each element corresponds to a text input and contains the rhythmic states for each syllable in that text.

Details

The function performs the following steps:

1. Splits each text into individual words
2. Applies syllabification to each word:
   • First word: first_word=true, silent_last_vowel=false
   • Last word: first_word=false, silent_last_vowel=true
   • Middle words: first_word=false, silent_last_vowel=false
3. Maps syllables to rhythmic states using the provided timing dictionary

Example

tajweed_timings = Dict{Bw,RState}(
    Bw("i") => RState(1, "short"),
    Bw("a") => RState(1, "short"),
    Bw("iy") => RState(2, "long"),
    Bw("aA") => RState(2, "long")
)

schillinger = Schillinger(tajweed_timings)
texts = [Bw("bisomi {ll~ahi")]
states = rhythmic_states(schillinger, texts)

See also: Schillinger, vis

Tournament Selection of Parent's Chromosome

The function selects the parent's chromosome using tournament selection

params: ayahs_emb - Ayah embeddings mp - Midpoints of the Ayah k - The size of samples from where the parent is chosen

syllabic_consistency(segments::Vector{Segment}, syllable_timings::Dict{Bw,RState})

Compute syllabicconsistency from a given segments and `syllabletimings`. THIS WILL ONLY WORK IF THE VOWEL HAS ONLY 1 TRAIL

julia> using Yunir
julia> using QuranTree
julia> crps, tnzl = load(QuranData());
julia> crpstbl = table(crps)
julia> tnzltbl = table(tnzl)
julia> bw_texts = verses(tnzltbl[2])
julia> texts = string.(split(bw_texts[1]))
julia> r = Syllabification(true, Syllable(1, 0, 5))
julia> segments = Segment[]
julia> j = 1
julia> for i in texts
			if j == 1
				push!(segments, r(encode(i), first_word=true, silent_last_vowel=false))
			elseif j == length(texts)
				push!(segments, r(encode(i), first_word=false, silent_last_vowel=true))
			else
				push!(segments, r(encode(i), first_word=false, silent_last_vowel=false))
			end
			j += 1
		end
julia> tajweed_timings = Dict{Bw,RState}(
    Bw("i") => RState(1, "short"), # kasra
    Bw("a") => RState(1, "short"), # fatha
    Bw("u") => RState(1, "short"), # damma
    Bw("F") => RState(1, "short"), # fatha tanween
    Bw("N") => RState(1, "short"), # damma tanween
    Bw("K") => RState(1, "short"), # kasra tanween
    Bw("iy") => RState(2, "long"), # kasra + yaa
    Bw("aA") => RState(2, "long"), # fatha + alif
    Bw("uw") => RState(2, "long"), # damma + waw
    Bw("a`") => RState(2, "long"),
    Bw("^") => RState(4, "maddah") # maddah
)

julia> syllabic_consistency(segments, tajweed_timings)

to_numbers(texts::Vector{LastRecitedSyllable})

Convert syllables to numeric y-axis positions for visualization.

Assigns a unique integer to each unique syllable in the order of first appearance. This mapping is used to position syllables on the y-axis of the visualization plot.

Arguments

• texts::Vector{LastRecitedSyllable}: Array of syllables to convert

Returns

A tuple containing:

• Vector{Int64}: Numeric position for each syllable in texts (same length as input)
• Dict{LastRecitedSyllable,Int64}: Dictionary mapping each unique syllable to its assigned position

Examples

syllables = [syl1, syl2, syl1, syl3]  # syl1 appears twice
positions, mapping = to_numbers(syllables)
# positions = [1, 2, 1, 3]  # Same syllables get same position
# mapping = Dict(syl1=>1, syl2=>2, syl3=>3)

tokenize(s::String)

tokenizes the string input s by space, and also tokenizes the punctuations.

julia> ar_basmala = "بِسْمِ ٱللَّهِ ٱلرَّحْمَٰنِ ٱلرَّحِيمِ"
julia> tokenize(ar_basmala)
4-element Vector{String}:
 "بِسْمِ"
 "ٱللَّهِ"
 "ٱلرَّحْمَٰنِ"
 "ٱلرَّحِيمِ"

vis(rhythms::Vector{Vector{RState}}, fig::Makie.Figure=Figure(size=(900,900)),
    title::String="Title", xlabel::String="Time in Seconds", ylabel::String="Line") -> Figure

Visualizes Joseph Schillinger's rhythmic graph using a staircase plot.

Arguments

• rhythms::Vector{Vector{RState}}: A vector of rhythmic state sequences, typically output from rhythmic_states. Each inner vector represents the rhythmic pattern of one line/verse.
• fig::Makie.Figure: Optional pre-existing Makie Figure object. Defaults to a new Figure with size (900, 900).
• title::String: Title for the plot. Defaults to "Title".
• xlabel::String: Label for the x-axis. Defaults to "Time in Seconds".
• ylabel::String: Label for the y-axis. Defaults to "Line".

Returns

• Makie.Figure: A Makie Figure object containing the rhythmic visualization.

Details

The visualization creates a separate subplot for each input text, displaying the rhythmic pattern as a staircase plot where:

• Each step represents a rhythmic state
• The width of each step corresponds to the duration of that state
• Steps alternate between two levels (0 and 1) to clearly show rhythmic changes
• All subplots share the same x-axis for easy comparison

Example

tajweed_timings = Dict{Bw,RState}(
    Bw("i") => RState(1, "short"), # kasra
    Bw("a") => RState(1, "short"), # fatha
    Bw("u") => RState(1, "short"), # damma
    Bw("F") => RState(1, "short"), # fatha tanween
    Bw("N") => RState(1, "short"), # damma tanween
    Bw("K") => RState(1, "short"), # kasra tanween
    Bw("iy") => RState(2, "long"), # kasra + yaa
    Bw("aA") => RState(2, "long"), # fatha + alif
    Bw("uw") => RState(2, "long"), # damma + waw
    Bw("a`") => RState(2, "long"),
    Bw("^") => RState(4, "maddah") # maddah
)

bw_texts = [
    Bw("bisomi {ll~ahi {lr~aHoma`ni {lr~aHiymi"),
    Bw("{loHamodu lil~ahi rab~i {loEa`lamiyna"),
    Bw("{lr~aHoma`ni {lr~aHiymi"),
    Bw("ma`liki yawomi {ld~iyni"),
    Bw("<iy~aAka naEobudu wa<iy~aAka nasotaEiynu"),
    Bw("{hodinaA {lS~ira`Ta {lomusotaqiyma"),
    Bw("Sira`Ta {l~a*iyna >anoEamota Ealayohimo gayori {lomagoDuwbi Ealayohimo walaA {lD~aA^l~iyna")
]
rhythms = rhythmic_states(Schillinger(tajweed_timings), bw_texts)
fig = vis(rhythms)

See also: Schillinger, rhythmic_states

vis(x1::Vector{LastRecitedSyllable}, y1::Vector{Int64}; kwargs...)

Create a Makie figure visualizing the progression of last recited syllables across texts.

The function creates 1-3 vertically stacked subplots depending on which optional data arguments are provided. Each subplot shows a line plot tracking how the last recited syllable patterns change across the sequence of texts.

Arguments

• x1::Vector{LastRecitedSyllable}: Syllable data for the first (required) subplot
• y1::Vector{Int64}: Numeric y-axis positions for the first subplot

Keyword Arguments

• x2::Union{Nothing,Vector{LastRecitedSyllable}}=nothing: Optional syllable data for second subplot
• y2::Union{Nothing,Vector{Int64}}=nothing: Optional y-axis positions for second subplot
• x3::Union{Nothing,Vector{LastRecitedSyllable}}=nothing: Optional syllable data for third subplot
• y3::Union{Nothing,Vector{Int64}}=nothing: Optional y-axis positions for third subplot
• fig::Makie.Figure=Makie.Figure(resolution=(800, 800)): The Makie figure to draw into
• title::String="Title": Title displayed at the top of the figure
• xlabel::String="Line Index": Label for the x-axis
• ylabel::Vector{String}: Y-axis labels for up to 3 subplots (defaults to syllable descriptions)
• fig_kwargs...: Additional keyword arguments passed to the lines! function

Returns

• Makie.Figure: The figure with rendered visualization

Subplot Behavior

• If only x1/y1 provided: Creates single subplot
• If x1/y1 and x2/y2 provided: Creates 2 vertically stacked subplots
• If all x1/y1, x2/y2, and x3/y3 provided: Creates 3 vertically stacked subplots

Examples

# Single subplot
fig = vis(syllables1, positions1, title="Last Syllable Analysis")

# Two subplots
fig = vis(syllables1, positions1, x2=syllables2, y2=positions2)

# Three subplots with custom styling
fig = vis(syllables1, positions1,
          x2=syllables2, y2=positions2,
          x3=syllables3, y3=positions3,
          title="Complete Analysis",
          color=:blue, linewidth=2)

@transliterator(dict, name)

Create a custom transliterator using an input dict (Dict object) with its corresponding name as String object. This will automatically update the transliterator inside all functions like arabic, verses, and encode.

Examples

julia> my_encoder = Dict(
    Symbol(Char(0x0621)) => Symbol('('),
    Symbol(Char(0x0622)) => Symbol('''),
    Symbol(Char(0x0623)) => Symbol('&'),
    Symbol(Char(0x0624)) => Symbol('>'),
    Symbol(Char(0x0625)) => Symbol('}'),
    Symbol(Char(0x0626)) => Symbol('<'),
    Symbol(Char(0x0627)) => Symbol('b'),
    Symbol(Char(0x0628)) => Symbol('A'),
    Symbol(Char(0x0629)) => Symbol('t'),
    Symbol(Char(0x062A)) => Symbol('p'),
    Symbol(Char(0x062B)) => Symbol('j'),
    Symbol(Char(0x062C)) => Symbol('v'),
    Symbol(Char(0x062D)) => Symbol('x'),
    Symbol(Char(0x062E)) => Symbol('H'),
    Symbol(Char(0x062F)) => Symbol('*'),
    Symbol(Char(0x0630)) => Symbol('d'),
    Symbol(Char(0x0631)) => Symbol('z'),
    Symbol(Char(0x0632)) => Symbol('r'),
    Symbol(Char(0x0633)) => Symbol('$'),
    Symbol(Char(0x0634)) => Symbol('s'),
    Symbol(Char(0x0635)) => Symbol('D'),
    Symbol(Char(0x0636)) => Symbol('S'),
    Symbol(Char(0x0637)) => Symbol('Z'),
    Symbol(Char(0x0638)) => Symbol('T'),
    Symbol(Char(0x0639)) => Symbol('g'),
    Symbol(Char(0x063A)) => Symbol('E'),
    Symbol(Char(0x0640)) => Symbol('f'),
    Symbol(Char(0x0641)) => Symbol('_'),
    Symbol(Char(0x0642)) => Symbol('k'),
    Symbol(Char(0x0643)) => Symbol('q'),
    Symbol(Char(0x0644)) => Symbol('m'),
    Symbol(Char(0x0645)) => Symbol('l'),
    Symbol(Char(0x0646)) => Symbol('h'),
    Symbol(Char(0x0647)) => Symbol('n'),
    Symbol(Char(0x0648)) => Symbol('Y'),
    Symbol(Char(0x0649)) => Symbol('w'),
    Symbol(Char(0x064A)) => Symbol('F'),
    Symbol(Char(0x064B)) => Symbol('y'),
    Symbol(Char(0x064C)) => Symbol('K'),
    Symbol(Char(0x064D)) => Symbol('N'),
    Symbol(Char(0x064E)) => Symbol('u'),
    Symbol(Char(0x064F)) => Symbol('a'),
    Symbol(Char(0x0650)) => Symbol('~'),
    Symbol(Char(0x0651)) => Symbol('i'),
    Symbol(Char(0x0652)) => Symbol('^'),
    Symbol(Char(0x0653)) => Symbol('o'),
    Symbol(Char(0x0654)) => Symbol('`'),
    Symbol(Char(0x0670)) => Symbol('#'),
    Symbol(Char(0x0671)) => Symbol(':'),
    Symbol(Char(0x06DC)) => Symbol('{'),
    Symbol(Char(0x06DF)) => Symbol('"'),
    Symbol(Char(0x06E0)) => Symbol('@'),
    Symbol(Char(0x06E2)) => Symbol(';'),
    Symbol(Char(0x06E3)) => Symbol('['),
    Symbol(Char(0x06E5)) => Symbol('.'),
    Symbol(Char(0x06E6)) => Symbol(','),
    Symbol(Char(0x06E8)) => Symbol('-'),
    Symbol(Char(0x06EA)) => Symbol('!'),
    Symbol(Char(0x06EB)) => Symbol('%'),
    Symbol(Char(0x06EC)) => Symbol('+'),
    Symbol(Char(0x06ED)) => Symbol(']')
);
julia> @transliterator my_encoder "MyEncoder"
julia> encode(ar_basmala)
"A~$^l~ :mmiun~ :mziux^lu#h~ :mziux~Fl~"

@transliterator(symbl)

Fallback to the default Buckwalter transliterator.

julia> @transliterator :default
julia> ar_basmala = "بِسْمِ ٱللَّهِ ٱلرَّحْمَٰنِ ٱلرَّحِيمِ"
julia> encode(ar_basmala)
"bisomi {ll~ahi {lr~aHoma`ni {lr~aHiymi"