এই পর্বে যা শিখবেন
- বিভিন্ন ভাষা string-কে মেমরিতে কীভাবে রাখে, আর প্রতিটি নকশার সুবিধা, দাম আর নিরাপত্তা-ঝুঁকি
- Unicode-এর code point, plane আর বাংলা block; হসন্ত, নুক্তা, ZWJ আর ZWNJ কী কাজ করে
- হাতে UTF-8 আর UTF-16 encoding করা, আর ছোট একটি encoder লিখে Python-এর সঙ্গে মেলানো
- একটি বাংলা শব্দের “দৈর্ঘ্য” চার রকমে গোনা, normalization (NFC/NFD) আর তুলনা-সাজানোর ফাঁদ
- Haat-এর
Strtype, lexer-এ escape আর কলাম গোনা, আর একটি ভাষা-নকশার সিদ্ধান্ত হিসেবে এগুলোর বিচার
১ · String আসলে কিসের সারি? — ভাষা নকশার প্রথম প্রশ্ন
সব ভাষাতেই string আছে: নাম, ঠিকানা, রসিদের লেখা। কিন্তু “string মানে অক্ষরের সারি” বললে আসল প্রশ্নটি এড়িয়ে যাওয়া হয়। অক্ষর বলতে ঠিক কী? এই প্রশ্নের উত্তর প্রতিটি ভাষা নিজে ঠিক করে, আর সেই উত্তরই ঠিক করে length কী গুনবে, s[1] কী ফেরত দেবে, আর বাংলা লেখা কাটলে ভাঙবে কি না।
বাজারঘরের গুদামে একজন কর্মী মালের ফর্দ গুনছেন। “কতগুলো জিনিস?” প্রশ্নের উত্তর চারভাবে হতে পারে: বাক্সের সংখ্যা, প্যাকেটের সংখ্যা, প্যাকেটের ভেতরের টুকরোর সংখ্যা, বা ক্রেতা চোখে যা “একটি জিনিস” দেখেন তার সংখ্যা। চালের একটি বস্তা ক্রেতার কাছে একটি জিনিস, গুদামের খাতায় হয়তো দুটি প্যাকেট, আর ট্রাকের হিসাবে ছয়টি ছোট বাক্স। কেউ ভুল গুনছে না; প্রত্যেকে আলাদা একক গুনছে। String-এর দৈর্ঘ্যও ঠিক এমন।
এই পর্বজুড়ে চারটি একক বারবার আসবে। নিচ থেকে ওপরে:
- Byte: মেমরি বা ফাইলের ৮ বিটের ঘর। Encoding ঠিক করে একটি অক্ষর কত byte নেবে।
- Code unit: একটি encoding-এর মৌলিক টুকরো। UTF-8-এ ৮ বিট, UTF-16-এ ১৬ বিট, UTF-32-এ ৩২ বিট।
- Code point: Unicode-এ একটি চিহ্নের নম্বর, যেমন ক = U+0995, হসন্ত = U+09CD.
- Grapheme cluster: পাঠক চোখে যাকে একটি অক্ষর দেখেন, যেমন “ক্ষ” বা “মা”। ভেতরে এটি একাধিক code point হতে পারে।
এখন দেখুন বড় ভাষাগুলো কোন একককে “string-এর উপাদান” বলে বেছে নিয়েছে। এটি কোনো লাইব্রেরির খুঁটিনাটি নয়; ভাষার semantics-এর অংশ, কারণ length, index আর slicing-এর অর্থ এর ওপর দাঁড়িয়ে।
| ভাষা (version) | String-এর উপাদান | “ক্ষমা”-র length | বদলানো যায়? |
|---|---|---|---|
| C17 | byte (char), শেষে '\0'; encoding ভাষা বলে না | strlen = 15 (UTF-8 ফাইলে) | হ্যাঁ (array); literal বদলানো UB |
| Java 21 | UTF-16 code unit (char) | length() = 5 | না |
| JavaScript (ES2025) | UTF-16 code unit | .length = 5 | না |
| Python 3.14 | code point | len() = 5 | না |
| Rust 1.x | বৈধ UTF-8 byte; chars() দেয় code point | len() = 15 | String হ্যাঁ, &str না |
| Go 1.x | byte (সাধারণত UTF-8); range দেয় rune | len() = 15 | না |
| Swift 5 | grapheme cluster (Character) | count = 2 | হ্যাঁ (value type) |
| Haat v1 | code point (reference Python-এর str ব্যবহার করে) | (length নেই) | না |
Python, Java আর JavaScript-এর সংখ্যাগুলো এই পর্বের সত্যিকারের run থেকে; C-র সংখ্যা Clang-এর run থেকে (অংশ ২)। Rust, Go আর Swift-এর সারি তাদের documentation-এর নিয়ম থেকে লেখা, এখানে চালানো হয়নি; Swift-এর 2 এসেছে এই নিয়ম থেকে যে Character একটি grapheme cluster, আর ব্রাউজারের Unicode-ভিত্তিক segmenter “ক্ষমা”-কে ২টি cluster গুনেছে (অংশ ৬)। Character type-এর ভাষাভেদ (C-র char, Java-র ১৬-বিট char) নিয়ে আলোচনা আছে পর্ব ২০-এ। Haat v1-এ string-এর length বা index নেওয়ার কোনো operator নেই; অনুশীলন ১-এ আপনি একটি নকশা করবেন।
২ · মেমরিতে string রাখার চার নকশা
“কিসের সারি” ঠিক হলে পরের প্রশ্ন: সারিটি কোথায় শেষ, সেটি কীভাবে জানা যাবে? মেমরি তো একটানা byte; কোথাও লেখা থাকে না “লেখা এখানে শেষ”। ভাষাগুলো চারটি প্রধান উত্তর দিয়েছে। নিচের ছবিতে বাজারঘরের একটি ছোট ASCII শব্দ chal (চাল) চার নকশায় দেখানো হলো।
ছবি ২১.১ — একই string “chal”, চার রকম মেমরি-নকশা
প্রতিটি ছোট বাক্স একটি byte. তীর মানে ঠিকানা (pointer).
নকশা ১: শেষে শূন্য byte (C)
C-তে string আলাদা কোনো type নয়; এটি char-এর array, যার শেষে একটি শূন্য byte বসে, যাকে বলে null terminator. Dennis Ritchie তাঁর “The Development of the C Language” (১৯৯৩) প্রবন্ধে লিখেছেন, পূর্বসূরি BCPL দৈর্ঘ্য রাখত প্রথম ঘরে, আর B ও C শেষে একটি চিহ্ন বেছে নেয়: আংশিক কারণ ৮ বা ৯ বিটের ঘরে দৈর্ঘ্যের সীমা এড়ানো, আংশিক কারণ তাঁদের অভিজ্ঞতায় শেষ-চিহ্ন বেশি সুবিধাজনক মনে হয়েছিল। দাম তিনটি। দৈর্ঘ্য জানতে প্রতিবার শূন্য পর্যন্ত হাঁটতে হয়। লেখার মাঝে শূন্য byte রাখা যায় না। আর শূন্যটি হারালে বা buffer-এর মাপ ভুল হলে function পাশের মেমরি পড়তে-লিখতে থাকে, যা buffer overflow-এর পুরোনো উৎস। Poul-Henning Kamp ২০১১ সালে ACM Queue-তে এই সিদ্ধান্তকে “The Most Expensive One-byte Mistake” বলেছিলেন। সত্যিকারের run দেখুন:
#include <stdio.h>
#include <string.h>
int main(void) {
const char shop[] = "বাজারঘর"; /* UTF-8 bytes + one '\0' */
const char item[] = "chal\0dal"; /* a '\0' in the middle */
printf("sizeof shop = %zu, strlen shop = %zu\n", sizeof shop, strlen(shop));
printf("sizeof item = %zu, strlen item = %zu\n", sizeof item, strlen(item));
printf("first bytes:");
for (size_t i = 0; i < 4; i++)
printf(" %02X", (unsigned char)shop[i]);
printf("\nitem prints as: %s\n", item);
return 0;
}~/haat $ zig cc -std=c17 -Wall -Wextra cstr.c -o cstr.exe && ./cstr.exe
sizeof shop = 22, strlen shop = 21
sizeof item = 9, strlen item = 4
first bytes: E0 A6 AC E0
item prints as: chal
সত্যিকারের run: PyPI-র ziglang 0.17.1 (MIT licence), যার ভেতরে Clang 22.1.8; কোনো warning আসেনি। Wandbox এই সময়ে কাজ করছিল না বলে C কোড পাতায় চালানোর ব্লক হিসেবে রাখা হয়নি। প্রথম লাইন: source ফাইল UTF-8-এ, আর Clang literal-এর byte-গুলো সেভাবেই রেখেছে: ৭টি code point × ৩ byte = 21, সঙ্গে শেষের শূন্য মিলে array-এর মাপ 22. C-র strlen অক্ষর নয়, byte গোনে। দ্বিতীয় লাইন: literal-এ ৮টি দৃশ্যমান byte আর একটি লুকানো শূন্য, কিন্তু strlen প্রথম শূন্যেই থেমে 4 বলে, আর printf("%s") ছাপে শুধু chal; “dal” মেমরিতে আছে, কিন্তু string-এর অংশ হিসেবে অদৃশ্য। তৃতীয় লাইন: “ব”-এর UTF-8 byte E0 A6 AC, তারপর “া”-র প্রথম byte E0. এই byte-গুলো কোথা থেকে এল, অংশ ৫-এ হাতে বের করবেন। C-র string library-র বিস্তারিত আছে C কোর্সের পর্ব ১৯-এ, আর buffer overflow-এর প্রতিরোধ Cybersecurity কোর্সের পর্ব ৪৭-এ।
নকশা ২, ৩ আর ৪
শুরুতে দৈর্ঘ্য (length-prefixed string): UCSD Pascal আর পরে Turbo Pascal-এর string type প্রথম byte-এ দৈর্ঘ্য রাখত বলে সুপরিচিত, তাই সর্বোচ্চ ২৫৫ অক্ষর। দৈর্ঘ্য এক ধাপে জানা যায়, মাঝে শূন্যও রাখা যায়। আধুনিক রূপে দৈর্ঘ্যের ঘর বড় (৪ বা ৮ byte), তাই সীমার প্রশ্ন কার্যত থাকে না।
ঠিকানা আর দৈর্ঘ্যের জোড়া: Rust-এর &str, Go-র string আর C++17-এর std::string_view দুটি ঘরের একটি ছোট মান: byte-গুলোর শুরুর ঠিকানা আর দৈর্ঘ্য। একে বলে fat pointer. বড় সুবিধা: একটি অংশ (substring) নিতে কপি লাগে না, শুধু নতুন ঠিকানা আর দৈর্ঘ্য। দাম হলো lifetime: মূল byte-গুলো মুছে গেলে জোড়াটি dangling হয়ে যায়। Rust compiler এটি ধরে, C++ ধরে না (পর্ব ১৬-এ lifetime দেখেছেন)।
Header-সহ object: Java, Python আর JavaScript-এ string heap-এর একটি object. Header-এ type-এর তথ্য, দৈর্ঘ্য, আর অনেক সময় একবার হিসাব করা hash থাকে, তাই dictionary-র key হিসেবে বারবার ব্যবহার সস্তা। এই ভাষাগুলোর string immutability মেনে চলে: তৈরির পরে ভেতরের মান বদলায় না। সেটি পরের অংশের বিষয়।
৩ · Immutable string, interning আর জোড়া দেওয়ার দাম
Java, Python, JavaScript আর Go string-কে immutable করেছে; C++-এর std::string আর Rust-এর String বদলানো যায়। Immutable হওয়ার চারটি বড় লাভ: এক, একই string নিরাপদে অনেক জায়গায় ভাগ করা যায়, কপি ছাড়াই, কারণ কেউ বদলাতে পারবে না (পর্ব ১৪-এর aliasing-এর ভয় নেই)। দুই, hash একবার হিসাব করে রেখে দেওয়া যায়, আর dictionary-র key বদলে গিয়ে ভুল ঘরে পড়ে থাকার ঝুঁকি নেই। তিন, একাধিক thread lock ছাড়াই পড়তে পারে। চার, সমান লেখার একটিমাত্র কপি রাখা যায়, যাকে বলে interning: Java-র string pool-এ সব literal থাকে, আর CPython identifier-এর মতো দেখতে অনেক string নিজে থেকেই intern করে।
দামটা আসে জোড়া দেওয়ায়। a + b মানে নতুন একটি object, যেখানে দুটির সব code unit কপি হয়, তাই string concatenation-এর খরচ মোট দৈর্ঘ্যের সমানুপাতিক। একটি loop-এ n বার একটি করে অক্ষর জুড়লে মোট কপি হয় প্রায় 1 + 2 + … + n, অর্থাৎ O(n²)। সমাধান string builder: টুকরোগুলো আগে একটি বাড়তে-পারা buffer-এ জমানো, শেষে একবার string বানানো (Java-র StringBuilder, Python-এর "".join(list)). বাস্তবায়নগুলো নিজেরাও কৌশল খাটায়: Java 9 থেকে + compile হয় invokedynamic আর StringConcatFactory দিয়ে (JEP 280); CPython-এ s += t বিশেষ ক্ষেত্রে, যখন s-এর আর কোনো reference নেই, জায়গায় বড় করা হয়, কিন্তু এটি CPython-এর বাস্তবায়ন, ভাষার নিশ্চয়তা নয়, তাই PEP 8 এর ওপর ভরসা না করতে বলে। JavaScript engine-গুলো অনেক সময় জোড়াকে সঙ্গে সঙ্গে কপি না করে দুই টুকরোর একটি গাছ রাখে, যা rope-এর ধারণা (engine-ভেদে আলাদা, ভাষার নিয়ম নয়)। C++-এর বহু বাস্তবায়ন ছোট string-কে object-এর ভেতরেই রাখে, heap ছাড়া: small string optimization.
CPython একটি string-এ প্রতি অক্ষরে কত byte রাখে
Python ভাষা বলে string code point-এর সারি। কিন্তু প্রতিটি code point-এর জন্য ৪ byte রাখলে ইংরেজি লেখায় তিন-চতুর্থাংশ জায়গা নষ্ট। CPython 3.3 থেকে (PEP 393, “flexible string representation”) প্রতিটি string তার সবচেয়ে বড় code point দেখে ঠিক করে প্রতি অক্ষরে ১, ২ নাকি ৪ byte রাখবে। Java 9-এর compact strings (JEP 254) একই ভাবনার: Latin-1-এ আঁটলে প্রতি অক্ষরে ১ byte, নইলে ২. নিচের কোড ব্রাউজারের Python-এ চালিয়ে দেখুন:
import sys, unicodedata as ud
print("Python", sys.version.split()[0], "| Unicode", ud.unidata_version)
for w in ["বাজারঘর", "ক্ষমা", chr(0x1F6D2)]:
u8, u16 = w.encode("utf-8"), w.encode("utf-16-le")
print(f"{w}: code points={len(w)} utf8 bytes={len(u8)} "
f"utf16 units={len(u16) // 2} utf32 bytes={len(w.encode('utf-32-le'))}")
for ch in "ক্ষমা":
print(f" U+{ord(ch):04X} {ud.category(ch)} {ud.name(ch)}")
# CPython (PEP 393): every str uses 1, 2 or 4 bytes per code point
for c in ["a", "ক", chr(0x1F6D2)]:
s10, s11 = c * 10, c * 11
print(f"{ascii(c):14} x10 size={sys.getsizeof(s10):3} "
f"one more char adds {sys.getsizeof(s11) - sys.getsizeof(s10)} bytes")
mixed = "a" * 10 + "ক"
print("10 x 'a' + one 'ক': size =", sys.getsizeof(mixed))আসল আউটপুট (ব্রাউজারের Python, Pyodide-এর CPython 3.14.2):
Python 3.14.2 | Unicode 16.0.0
বাজারঘর: code points=7 utf8 bytes=21 utf16 units=7 utf32 bytes=28
ক্ষমা: code points=5 utf8 bytes=15 utf16 units=5 utf32 bytes=20
🛒: code points=1 utf8 bytes=4 utf16 units=2 utf32 bytes=4
U+0995 Lo BENGALI LETTER KA
U+09CD Mn BENGALI SIGN VIRAMA
U+09B7 Lo BENGALI LETTER SSA
U+09AE Lo BENGALI LETTER MA
U+09BE Mc BENGALI VOWEL SIGN AA
'a' x10 size= 31 one more char adds 1 bytes
'\u0995' x10 size= 50 one more char adds 2 bytes
'\U0001f6d2' x10 size= 72 one more char adds 4 bytes
10 x 'a' + one 'ক': size = 52
প্রথম অংশ: “বাজারঘর” ৭টি code point, UTF-8-এ 21 byte, UTF-16-এ 7 unit. শপিং-ট্রলির ছবি (U+1F6D2) একটি code point, কিন্তু UTF-16-এ 2 unit আর UTF-8-এ 4 byte; কেন, অংশ ৫-এ। দ্বিতীয় অংশ: “ক্ষমা”-র পাঁচটি code point আর তাদের Unicode নাম: হসন্ত (VIRAMA) category Mn (non-spacing mark), আকার (AA) Mc (spacing mark), বাকিরা Lo (letter). তৃতীয় অংশ: একটি অক্ষর বাড়ালে ASCII string 1 byte, বাংলা string 2 byte, emoji-র string 4 byte বাড়ে: PEP 393-এর তিন রকম ঘর সরাসরি দেখা যাচ্ছে। শেষ লাইন: দশটি a-র সঙ্গে একটি মাত্র “ক” যোগ হলেই পুরো string ২-byte-এর ঘরে চলে যায়। মোট মাপের সংখ্যাগুলো (header-সহ) যন্ত্রভেদে আলাদা: লেখকের ৬৪-বিট CPython 3.14.4-এ সারিগুলো 51, 78, 100 আর শেষ লাইন 80, আর ব্রাউজারের Pyodide (৩২-বিট WebAssembly-তে চলে) দিয়েছে 31, 50, 72 আর 52, কারণ সেখানে header ছোট। প্রতি অক্ষরে বাড়তি 1, 2, 4 কিন্তু দুই জায়গাতেই এক।
৪ · Unicode — প্রতিটি চিহ্নের একটি নম্বর
Unicode-এর মূল কথা সহজ: পৃথিবীর প্রায় সব লিপির প্রতিটি চিহ্নকে একটি স্থায়ী নম্বর দেওয়া। নম্বরের পরিসর U+0000 থেকে U+10FFFF, মোট ১১,১৪,১১২টি ঘর, যা ১৭টি plane-এ ভাগ করা, প্রতিটিতে ৬৫,৫৩৬টি। Plane 0-কে বলে Basic Multilingual Plane (BMP); আধুনিক প্রায় সব লিপি, বাংলাসহ, সেখানে। বাংলা লিপির block হলো U+0980 থেকে U+09FF. ASCII আর Unicode-এর পরিচয়, অভ্র-বিজয় আর ফন্টের সমস্যা আছে Computer Fundamentals কোর্সের পর্ব ০৭-এ আর পর্ব ১৮-এ; বিট-স্তরের দিক Computer Architecture কোর্সের পর্ব ০৬-এ। এখানে আমরা দেখব ভাষা আর compiler-এর দিক থেকে কোন খুঁটিনাটি জরুরি।
বাংলা লেখার ক্ষেত্রে প্রথম জরুরি কথা: Unicode “চোখে দেখা অক্ষর” নয়, লেখার উপাদান encode করে। কার-চিহ্ন আলাদা code point, আর যুক্তাক্ষরের জন্য আলাদা কোনো code point নেই। ক্ষ লেখা হয় তিনটি code point দিয়ে: ক (U+0995) + হসন্ত (U+09CD) + ষ (U+09B7). হসন্তকে Unicode-এর নামে বলে virama. কোন ক্রমে code point-গুলো এলে ফন্ট কোন যুক্ত রূপ আঁকবে, সেটি ফন্ট আর text-rendering engine-এর কাজ, string-এর নয়। চারটি বিশেষ চিহ্ন জানা দরকার:
| চিহ্ন | Code point | কাজ | উদাহরণ (code point) |
|---|---|---|---|
| হসন্ত (virama) | U+09CD | আগের ব্যঞ্জনের স্বরধ্বনি বাদ দেয়; পরে ব্যঞ্জন এলে সাধারণত যুক্তাক্ষর | ক্ষ = 0995 09CD 09B7 |
| নুক্তা | U+09BC | আগের অক্ষরের নিচে বিন্দু; ড + ় দেখতে ড় | ড় = 09A1 09BC |
| ZWJ | U+200D | অদৃশ্য; পাশের অক্ষরগুলোকে নির্দিষ্ট যুক্ত রূপে আঁকতে বলে | র্যা = 09B0 200D 09CD 09AF 09BE |
| ZWNJ | U+200C | অদৃশ্য; যুক্তাক্ষর না বানিয়ে হসন্ত দেখাতে বলে | ক্ষ = 0995 09CD 200C 09B7 |
শেষ দুই সারির উদাহরণ সত্যিকারের Python run থেকে নেওয়া। “র্যাব” লিখতে র-এর পরে ZWJ দিলে য-ফলা আলাদা দেখায়, রেফ হয় না; ZWNJ দিলে “ক্ষ” দেখায় হসন্তসহ ক আর পাশে ষ. তবে চোখে ঠিক কী দেখাবে, তা ফন্টের ওপর নির্ভর করে। Program-এর জন্য বড় শিক্ষা: দুটি string দেখতে প্রায় এক হলেও ভেতরে একটি অদৃশ্য code point বেশি থাকতে পারে; খোঁজা, তুলনা আর দৈর্ঘ্য সবই তাতে বদলায়। কার-চিহ্ন, হসন্ত আর নুক্তার মতো যে চিহ্ন আগের অক্ষরের সঙ্গে জুড়ে বসে, তাকে বলে combining mark.
৫ · Encoding — নম্বর থেকে byte: UTF-8, UTF-16, UTF-32
Code point একটি বিমূর্ত নম্বর। ফাইলে, network-এ বা মেমরিতে রাখতে হলে সেটিকে byte-এ লিখতে হয়; সেই নিয়মই encoding. তিনটি প্রধান:
- UTF-32: প্রতিটি code point সরাসরি ৪ byte-এ। সরল, i-তম code point এক ধাপে পাওয়া যায়, কিন্তু জায়গা বেশি।
- UTF-16: U+FFFF পর্যন্ত একটি ১৬-বিট unit; তার ওপরে দুটি unit, যাকে বলে surrogate pair. বাংলার প্রতিটি code point একটি unit.
- UTF-8: ১ থেকে ৪ byte. ASCII ১ byte-এ হুবহু আগের মতো, বাংলা ৩ byte, emoji সাধারণত ৪ byte.
UTF-8 নকশা করেন Ken Thompson আর Rob Pike, ১৯৯২ সালে, Plan 9 operating system-এর জন্য; ২০০৩ সালের RFC 3629 একে U+10FFFF পর্যন্ত, অর্থাৎ সর্বোচ্চ ৪ byte-এ বেঁধে দেয়। নিয়মটি একটি ছোট টেবিল:
| Code point-এর পরিসর | বিট | Byte-এর ছাঁচ |
|---|---|---|
| U+0000 – U+007F | ৭ | 0xxxxxxx |
| U+0080 – U+07FF | ১১ | 110xxxxx 10xxxxxx |
| U+0800 – U+FFFF | ১৬ | 1110xxxx 10xxxxxx 10xxxxxx |
| U+10000 – U+10FFFF | ২১ | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx |
প্রথম byte-এর শুরুর 1-গুলো বলে মোট কত byte, আর পরের প্রতিটি byte শুরু হয় 10 দিয়ে। এই নকশার তিনটি গুণ compiler আর runtime-এর জন্য খুব কাজের। ASCII-সামঞ্জস্য: পুরোনো ASCII ফাইল বদল ছাড়াই বৈধ UTF-8, আর বহু-byte অক্ষরের কোনো byte কখনো ASCII-র মতো দেখায় না, তাই " বা \n খোঁজা lexer বাংলা লেখার মাঝে ভুল করে থামবে না। Self-synchronizing: যেকোনো byte থেকে শুরু করে বড়জোর তিন ধাপ পেছালেই একটি অক্ষরের শুরু পাওয়া যায়। ক্রম রক্ষা: byte ধরে তুলনা করলে code point-এর ক্রমই আসে (অংশ ৮-এ সত্যিকারের run, অনুশীলন ২-এ প্রমাণ)। এবার “বা” হাতে encode করুন:
1text "বা" = U+09AC U+09BE2U+0800..U+FFFF: 3 bytes31110xxxx 10xxxxxx 10xxxxxx4split 16 bits: 4 + 6 + 65fill the x positions
| code point | |
| ১৬ বিট | |
| byte (বিট) | |
| byte (hex) |
- শুরু। “বা” দুটি code point: ব (U+09AC) আর আকার (U+09BE). দুটিকে আলাদা আলাদা encode করতে হবে।
- কত byte? 0x09AC পড়ে U+0800 থেকে U+FFFF-এর মধ্যে, তাই ৩ byte-এর ছাঁচ। Hex 09AC-কে বিটে লিখলে
0000 1001 1010 1100, মোট ১৬ বিট। - ভাগ করা। ছাঁচে x-এর ঘর ৪ + ৬ + ৬ = ১৬টি, তাই বিটগুলো ওপর থেকে ৪, ৬, ৬ করে কাটা:
0000,100110,101100. - বসানো।
1110-এর পরে 0000,10-এর পরে 100110,10-এর পরে 101100. ফল E0 A6 AC, যা অংশ ২-এর Clang run-এর প্রথম তিন byte-এর সঙ্গে হুবহু মেলে। - আকার। 0x09BE =
0000 1001 1011 1110; কাটা অংশ 0000, 100110, 111110; ফল E0 A6 BE. লক্ষ করুন, প্রথম দুই byte একই, কারণ দুটি code point একই বাংলা block-এ। - ফল। “বা” = E0 A6 AC E0 A6 BE, মোট ৬ byte. Decoder প্রথম byte-এর
1110দেখেই জানে পরের দুটি byte এই অক্ষরের। নিচের কোডের encoder ঠিক এই দুটি লাইনই ছাপে।
এবার নিয়মটি কোডে লিখে Python-এর নিজের str.encode-এর সঙ্গে মেলান। একই কোডে UTF-16-এর surrogate pair-এর হিসাবও আছে: code point থেকে 0x10000 বাদ দিলে ২০ বিট থাকে; ওপরের ১০ বিট যায় D800-এর সঙ্গে, নিচের ১০ বিট DC00-এর সঙ্গে।
def utf8_encode(cp):
if 0xD800 <= cp <= 0xDFFF or cp > 0x10FFFF:
raise ValueError(f"U+{cp:04X} is not a Unicode scalar value")
if cp < 0x80:
return [cp] # 0xxxxxxx
if cp < 0x800:
return [0xC0 | cp >> 6, 0x80 | cp & 0x3F] # 110xxxxx 10xxxxxx
if cp < 0x10000:
return [0xE0 | cp >> 12, 0x80 | cp >> 6 & 0x3F, 0x80 | cp & 0x3F]
return [0xF0 | cp >> 18, 0x80 | cp >> 12 & 0x3F,
0x80 | cp >> 6 & 0x3F, 0x80 | cp & 0x3F]
def utf16_units(cp):
if cp < 0x10000:
return [cp]
v = cp - 0x10000 # 20 bits left
return [0xD800 | v >> 10, 0xDC00 | v & 0x3FF] # surrogate pair
text = "Tk ৳ বা é " + chr(0x1F6D2)
mine = bytes(b for ch in text for b in utf8_encode(ord(ch)))
print("my UTF-8 == str.encode:", mine == text.encode("utf-8"), len(mine), "bytes")
for ch in "বা" + chr(0x1F6D2):
cp = ord(ch)
print(f"U+{cp:04X}", " ".join(f"{b:08b}" for b in utf8_encode(cp)),
"| utf16:", " ".join(f"{u:04X}" for u in utf16_units(cp)))
print("cut after 2 bytes:", mine[3:5], "->",
repr(mine[3:5].decode("utf-8", errors="replace")))
try:
utf8_encode(0xD83D)
except ValueError as e:
print("error:", e)আসল আউটপুট (ব্রাউজারের Python):
my UTF-8 == str.encode: True 21 bytes
U+09AC 11100000 10100110 10101100 | utf16: 09AC
U+09BE 11100000 10100110 10111110 | utf16: 09BE
U+1F6D2 11110000 10011111 10011011 10010010 | utf16: D83D DED2
cut after 2 bytes: b'\xe0\xa7' -> '�'
error: U+D83D is not a Unicode scalar value
প্রথম লাইন: ASCII, টাকার চিহ্ন ৳ (U+09F3), বাংলা, ১১ বিটের é আর ৪ byte-এর emoji মিশিয়ে ২১ byte; আমাদের ১০ লাইনের encoder Python-এর সঙ্গে প্রতিটি byte-এ মিলেছে। পরের তিন লাইন: stepper-এর দুটি ফল, আর শপিং-ট্রলির ৪ byte; UTF-16-এ সেটি D83D DED2, একটি surrogate pair. পঞ্চম লাইন: ৳-এর ৩ byte-এর প্রথম দুটি কেটে নিয়ে decode করলে অসম্পূর্ণ অক্ষর পাওয়া যায়; errors="replace" সেখানে বসায় U+FFFD, যাকে বলে replacement character (পর্দায় সাধারণত প্রশ্নবোধক-চিহ্নওয়ালা হীরা)। ভুল encoding-এ পড়া বাংলা লেখায় যে চিহ্ন দেখেন, তা এটাই। শেষ লাইন: D800–DFFF পরিসরের নম্বরগুলো শুধু UTF-16-এর জোড়ার জন্য সংরক্ষিত, আলাদা চিহ্ন নয়; তাই এগুলো UTF-8-এ লেখা নিষেধ, আর আমাদের encoder তা প্রত্যাখ্যান করে।
UTF-16 কোথা থেকে এল, তা বুঝলে Java আর JavaScript-এর আচরণ পরিষ্কার হয়। Unicode 1.0 (১৯৯১) ভেবেছিল ১৬ বিটেই সব লিপি আঁটবে, তাই প্রতিটি অক্ষর একটি ১৬-বিট unit (এই রূপকে বলে UCS-2). Java (১৯৯৫-৯৬), JavaScript (১৯৯৫) আর Windows NT সেই সময় ১৬-বিটের char বেছে নেয়। পরে Unicode 2.0 (১৯৯৬) পরিসর বাড়ায় আর surrogate pair আনে; তখন ভাষাগুলোর আর char-এর অর্থ বদলানোর উপায় ছিল না, কারণ লাখো program সেই অর্থের ওপর দাঁড়িয়ে। Java 5 code point-এর জন্য আলাদা method যোগ করে; JavaScript-এ ES2015 আনে codePointAt আর for…of. একটি ভাষার প্রথম দিনের সিদ্ধান্ত কয়েক দশক টিকে থাকে, পর্ব ০৬-এর backward compatibility-র আলোচনার একটি পাঠ্যপুস্তকীয় উদাহরণ।
৬ · “দৈর্ঘ্য” চার রকম — ক্ষমা কত অক্ষর?
অংশ ১-এর চারটি একক এখন একটি শব্দে প্রয়োগ করা যাক। “ক্ষমা” চোখে দুটি অক্ষর: ক্ষ আর মা. ভেতরে কী আছে, ধাপে ধাপে:
1"ক্ষমা" = ক ্ ষ ম া2UTF-8 bytes (C strlen, Rust, Go)3UTF-16 units (Java, JavaScript)4code points (Python, Haat)5graphemes (Swift, Segmenter)
| একক | |
| টুকরোগুলো | |
| গণনা |
- ভেতরের উপাদান। পাঁচটি code point: ক (0995), হসন্ত (09CD), ষ (09B7), ম (09AE), আকার (09BE). এটি সত্যিকারের Python run-এর তালিকা।
- Byte. প্রতিটি বাংলা code point UTF-8-এ ৩ byte, তাই ৫ × ৩ = 15. C-র
strlen, Rust-এরstr::lenআর Go-রlenএটিই বলে। - UTF-16 unit. সবগুলো BMP-তে, তাই প্রতিটি একটি unit: 5. Java-র
length()আর JavaScript-এর.length. - Code point. এখানেও 5, কারণ কোনো surrogate pair নেই। Python-এর
len(), আর Haat reference-এর ভেতরের হিসাব। - Grapheme. Unicode-এর UAX #29 নিয়মে ক + হসন্ত + ষ একটি cluster (Unicode 15.1, ২০২৩-এর পর থেকে), আর ম + আকার আরেকটি: মোট 2. ব্রাউজারের
Intl.Segmenterএটিই দিয়েছে। - সারাংশ। 15, 5, 5, 2. শপিং-ট্রলির ছবিতে চারটি আলাদা: 4 byte, 2 unit, 1 code point, 1 grapheme. বাংলায় unit আর code point সমান হলেও emoji-তে আলাদা।
পঞ্চম ধাপের সাবধানবাণী গুরুত্বপূর্ণ। Grapheme-এর নিয়ম Unicode-এর version-এর সঙ্গে বদলায়। লেখকের যন্ত্রে Unicode 13 নিয়মে বানানো একটি পুরোনো Python লাইব্রেরি (grapheme 0.6.0, MIT licence) একই শব্দকে ভাগ করেছে ['ক্', 'ষ', 'মা'], অর্থাৎ ৩টি; Unicode 15.1 ভারতীয় লিপির যুক্তাক্ষরের জন্য নতুন নিয়ম (GB9c) যোগ করার পর হলো ২টি। তাই “grapheme কয়টি” প্রশ্নের উত্তরে Unicode আর লাইব্রেরির version বলতে হয়। নিচের JavaScript ব্রাউজারেই চালান:
const seg = new Intl.Segmenter("bn", { granularity: "grapheme" });
const cart = String.fromCodePoint(0x1F6D2);
for (const w of ["বাজারঘর", "ক্ষমা", cart]) {
const graphemes = [...seg.segment(w)].map(g => g.segment);
console.log(w, "| length:", w.length, "| code points:", [...w].length,
"| UTF-8 bytes:", new TextEncoder().encode(w).length,
"| graphemes:", graphemes.length, "=", graphemes.join(" + "));
}
console.log("charCodeAt:", cart.charCodeAt(0).toString(16), cart.charCodeAt(1).toString(16),
"| codePointAt:", cart.codePointAt(0).toString(16));
const half = cart.slice(0, 1);
console.log("slice(0, 1):", half.length, "unit, well formed?", half.isWellFormed());
const two = [String.fromCodePoint(0xFFFD), cart];
console.log("sort() puts first:", [...two].sort()[0].codePointAt(0).toString(16));
const words = ["পহেলা", "প" + String.fromCodePoint(0x09DC) + "া", "হাট"];
console.log("sort():", [...words].sort().join(" "));
console.log("localeCompare bn:", [...words].sort((a, b) => a.localeCompare(b, "bn")).join(" "));
console.log("NFC first:", words.map(w => w.normalize("NFC")).sort().join(" "));আসল আউটপুট (ব্রাউজারের JavaScript; লেখকের Node.js 24-এও হুবহু এক):
বাজারঘর | length: 7 | code points: 7 | UTF-8 bytes: 21 | graphemes: 5 = বা + জা + র + ঘ + র
ক্ষমা | length: 5 | code points: 5 | UTF-8 bytes: 15 | graphemes: 2 = ক্ষ + মা
🛒 | length: 2 | code points: 1 | UTF-8 bytes: 4 | graphemes: 1 = 🛒
charCodeAt: d83d ded2 | codePointAt: 1f6d2
slice(0, 1): 1 unit, well formed? false
sort() puts first: 1f6d2
sort(): পহেলা পড়া হাট
localeCompare bn: পড়া পহেলা হাট
NFC first: পড়া পহেলা হাট
প্রথম তিন লাইন stepper-এর সংখ্যাগুলো নিশ্চিত করে; “বাজারঘর” ৭টি code point কিন্তু ৫টি grapheme (বা, জা, র, ঘ, র)। [...w] string-কে code point ধরে ভাঙে, তাই emoji-তে 1, অথচ .length 2. চতুর্থ-পঞ্চম লাইন: charCodeAt একটি করে unit দেয়, codePointAt জোড়া মিলিয়ে আসল নম্বর। slice(0, 1) জোড়ার অর্ধেক কেটে নিয়েছে, যা একা কোনো বৈধ অক্ষর নয়; ES2024-এর isWellFormed() সেটি false বলে ধরে। শেষ চার লাইন তুলনা আর সাজানোর বিষয়, অংশ ৮-এ ব্যাখ্যা।
Length-এর পছন্দ index-এর খরচও ঠিক করে। UTF-32 বা CPython-এর PEP 393 রূপে i-তম code point এক ধাপে পাওয়া যায়, কারণ প্রতিটির মাপ সমান। UTF-8-এ i-তম code point পেতে শুরু থেকে হাঁটতে হয়, O(n). Rust তাই s[0] লিখতে দেয় না, compile error দেয়; byte-পরিসর দিয়ে টুকরো নেওয়া যায়, কিন্তু অক্ষরের মাঝে কাটলে চলার সময় panic (Rust documentation-এর নিয়ম, এখানে চালানো হয়নি)। Swift একই কারণে integer দিয়ে index নিতে দেয় না, বিশেষ String.Index চায়। এখানে একটি ভাষা-নকশার নীতি দেখা যায়: যে কাজ ব্যয়বহুল, তাকে সস্তা দেখতে syntax দেওয়া উচিত নয়।
৭ · Normalization — দেখতে এক, ভেতরে আলাদা
“ড়” দুইভাবে লেখা যায়: একটি code point হিসেবে (U+09DC, BENGALI LETTER RRA), অথবা ড (U+09A1) আর নুক্তা (U+09BC) মিলিয়ে। একইভাবে ো-কার (U+09CB) একটি code point, আবার এ-কার (U+09C7) আর আ-কার (U+09BE) মিলিয়েও লেখা যায়। Unicode এমন জোড়াকে বলে canonical equivalence: অর্থে আর চেহারায় এক। কিন্তু program-এর == সাধারণত code point ধরে তুলনা করে, তাই দুটি সমান নয়। সমাধান Unicode normalization: তুলনার আগে দুটিকে একই রূপে আনা। দুটি প্রধান রূপ: NFD সবকিছু ভেঙে ফেলে (decompose), NFC ভেঙে তারপর যা জোড়া যায় জোড়ে (compose).
বাংলায় একটি চমকপ্রদ ব্যতিক্রম আছে। ড়, ঢ় আর য়-এর একক code point-গুলো (U+09DC, U+09DD, U+09DF) Unicode-এর composition exclusion তালিকায়। তাই NFC এগুলোকে ভেঙে দেয়, কিন্তু আর জোড়ে না: NFC-তে ড় সবসময় দুটি code point. ধাপে ধাপে “বড়ো” দেখুন, যেখানে ড় একক code point হিসেবে টাইপ করা:
1typed : ব ড় ো (3 code points)2NFD : decompose every char3 reorder marks by class4NFC : compose pairs again5 skip excluded (ড়)6compare with ==
| code point | |
| গণনা | |
| চোখে |
- টাইপ করা রূপ। ব (09AC), একক ড় (09DC), একক ো-কার (09CB): ৩টি code point.
- ভাঙা, প্রথম ধাপ। 09DC-এর canonical decomposition হলো 09A1 09BC (ড + নুক্তা)। এখন ৪টি।
- ভাঙা, দ্বিতীয় ধাপ। 09CB ভেঙে হয় 09C7 09BE (এ-কার + আ-কার)। এরপর combining class অনুযায়ী mark-গুলো সাজানো হয়; নুক্তার class 7, বাকিদের 0, তাই ক্রম বদলায় না। NFD-তে ৫টি code point.
- জোড়া। NFC এবার পাশাপাশি জোড়া খোঁজে। 09C7 + 09BE মিলে আবার 09CB হয়।
- বাদ দেওয়া জোড়া। 09A1 + 09BC মিলে 09DC হতে পারত, কিন্তু 09DC composition exclusion-এ আছে, তাই জোড়া হয় না। NFC = 09AC 09A1 09BC 09CB, ৪টি code point. টাইপ করা রূপটি তাই নিজেই NFC নয়।
- তুলনা। তিনটি রূপ চোখে এক, কিন্তু code point-এর সংখ্যা 3, 4, 5. সরাসরি
==মিথ্যা; দুটিকেই NFC-তে আনলে সত্য। নিচের Python run এটিই দেখায়।
import unicodedata as ud
RRA, DDA, NUKTA, O = chr(0x09DC), chr(0x09A1), chr(0x09BC), chr(0x09CB)
typed = "ব" + RRA + O # ড় typed as one code point
other = "ব" + DDA + NUKTA + O # ড + nukta, as another keyboard sends
hexs = lambda s: " ".join(f"{ord(c):04X}" for c in s)
for name, s in [("typed", typed), ("other", other)]:
print(f"{name}: {hexs(s)} | NFC: {hexs(ud.normalize('NFC', s))}"
f" | NFD: {hexs(ud.normalize('NFD', s))}")
print("typed == other:", typed == other)
print("NFC equal: ", ud.normalize("NFC", typed) == ud.normalize("NFC", other))
print("typed is NFC? ", ud.is_normalized("NFC", typed))
words = ["পহেলা", "প" + RRA + "া", "হাট"]
print("code point order:", sorted(words))
print("after NFC: ", sorted(ud.normalize("NFC", w) for w in words))
print("ASCII and digits:", sorted(["Zebra", "apple", "২", "১০"]))
cart, bad = chr(0x1F6D2), chr(0xFFFD)
for enc in [None, "utf-8", "utf-16-be"]:
a, b = (cart, bad) if enc is None else (cart.encode(enc), bad.encode(enc))
print(f"{enc or 'code points':11}: cart < U+FFFD ? {a < b}")আসল আউটপুট (ব্রাউজারের Python):
typed: 09AC 09DC 09CB | NFC: 09AC 09A1 09BC 09CB | NFD: 09AC 09A1 09BC 09C7 09BE
other: 09AC 09A1 09BC 09CB | NFC: 09AC 09A1 09BC 09CB | NFD: 09AC 09A1 09BC 09C7 09BE
typed == other: False
NFC equal: True
typed is NFC? False
code point order: ['পহেলা', 'পড়া', 'হাট']
after NFC: ['পড়া', 'পহেলা', 'হাট']
ASCII and digits: ['Zebra', 'apple', '১০', '২']
code points: cart < U+FFFD ? False
utf-8 : cart < U+FFFD ? False
utf-16-be : cart < U+FFFD ? True
প্রথম পাঁচ লাইন stepper-এর প্রতিটি ধাপ নিশ্চিত করে। বাস্তবে এই সমস্যা আসে যখন একজন বিক্রেতা এক keyboard layout-এ পণ্যের নাম লেখেন আর ক্রেতা অন্য layout-এ খোঁজেন: চোখে এক, কিন্তু খোঁজ ব্যর্থ। নিয়ম: বাইরে থেকে আসা লেখা ঢোকার মুখেই একবার NFC করে রাখুন। বাকি লাইনগুলো পরের অংশে।
Normalization ভাষার নিজের নিয়মেও ঢুকেছে। Python 3 non-ASCII identifier অনুমোদন করে, আর PEP 3131 অনুযায়ী parser প্রতিটি identifier-কে NFKC-তে এনে তুলনা করে; ফলে দুটি ভিন্ন code point-এ লেখা “একই” নাম একই variable. Haat উল্টো পথ নিয়েছে: identifier শুধু ASCII (reference-এর নকশা-সিদ্ধান্ত ৪), বাংলা থাকতে পারে শুধু comment আর string-এ। তাতে lexer সরল থাকে আর normalization-এর প্রশ্ন identifier-এ ওঠেই না। দুটিই যুক্তিসংগত নকশা; প্রথমটি ব্যবহারকারীর স্বাধীনতা বাড়ায়, দ্বিতীয়টি বাস্তবায়ন আর নিরাপত্তা সহজ রাখে (একই দেখতে দুটি আলাদা নামের ধোঁকা, যাকে বলে homoglyph, Haat-এর নামে হতে পারে না)।
৮ · তুলনা আর সাজানো — কার ক্রম?
দুটি string-এর < কী অর্থ বহন করবে, তারও তিনটি সম্ভাব্য উত্তর, আর ওপরের দুই run তিনটিই দেখিয়েছে।
- Code point-এর ক্রম: Python-এর
<আরsorted. সরল আর দ্রুত, কিন্তু মানুষের অভিধানের ক্রম নয়:'Zebra'আসে'apple'-এর আগে (Z = 0x5A, a = 0x61), আর “১০” আসে “২”-এর আগে, কারণ তুলনা অক্ষর ধরে, সংখ্যা ধরে নয়। আরও মজার: একক code point-এর ড় (09DC) বাংলা block-এ হ (09B9)-এর পরে বসে, তাই “পড়া” গেছে “পহেলা”-র পরে; NFC-তে ভাঙার পর ড (09A1) হ-এর আগে, তাই ক্রম উল্টে গেল। Normalization সাজানোর ক্রমও বদলায়। - Code unit-এর ক্রম: JavaScript-এর ডিফল্ট
sort()আর Java-রcompareToUTF-16 unit ধরে তুলনা করে। BMP-র ভেতরে এটি code point-এর ক্রমই, কিন্তু surrogate (D800–DFFF) বসে U+E000–U+FFFF-এর আগে। তাই JavaScript শপিং-ট্রলিকে (D83D …) U+FFFD-এর আগে রেখেছে, আর Python পরে। Python run-এর শেষ তিন লাইন একই কথা byte-এ দেখায়: UTF-8 byte-এর ক্রম code point-এর ক্রমের সঙ্গে মেলে, UTF-16-এর মেলে না। দুটি ভাষার মধ্যে sort করা ডেটা আদান-প্রদানে এই পার্থক্য সূক্ষ্ম bug আনে। - ভাষার নিয়মের ক্রম (collation): Unicode Collation Algorithm (UTS #10) আর CLDR-এর ভাষাভিত্তিক তথ্য, যা ICU লাইব্রেরি বাস্তবায়ন করে। JavaScript-এর
localeCompare(…, "bn")আর Java-রCollatorএই পথে যায়। এখানে “পড়া” এসেছে “পহেলা”-র আগে, যেভাবে ড়-কে ড-এর সঙ্গে রাখা অভিধানে আশা করা হয়। তবে ফল ICU আর CLDR-এর version-এর ওপর নির্ভর করে, আর বাংলা অভিধানের ঐতিহ্যগত ক্রমের প্রতিটি খুঁটিনাটি (যেমন ক্ষ-এর স্থান) সব লাইব্রেরিতে একই কি না, তা নিজে পরীক্ষা না করে ধরে নেওয়া ঠিক নয়।
ভাষা-নকশার শিক্ষা: < operator-এর জন্য code point বা code unit-এর ক্রমই ঠিক, কারণ তা দ্রুত, নির্ধারিত আর locale-নিরপেক্ষ; মানুষের জন্য সাজাতে আলাদা, নাম-দেওয়া API দরকার, যেখানে ভাষা বলে দিতে হয়। Haat এখানে আরও কড়া: < <= > >= শুধু Int-এর জন্য (নকশা-সিদ্ধান্ত ১১), তাই "চাল" < "ডাল" একটি type error. পরের অংশে সত্যিকারের run.
৯ · Haat-এর Str — compiler-এর ভেতরে string
এবার নিজের ভাষায় ফিরি। Haat v1-এর Str type-এর নিয়ম অল্প: + দুটি Str জোড়ে, == আর != তুলনা করে, print লেখাটি ছাপে; কোনো implicit রূপান্তর নেই, তাই "মোট " + 996 type error. Typing rule আকারে (Γ হলো type environment, Γ ⊢ e : τ পড়ুন “Γ-তে e-এর type τ”):
Type checker বাস্তবায়ন পর্ব ৫২-এ আসবে। Compiler-এর জন্য বেশি কাজ lexer-এ, যার পূর্ণ বাস্তবায়ন পর্ব ৪৬-এ; এখানে শুধু string-এর অংশ। Reference-এর lexer.py-তে দুটি ছোট function: scan_string খোলা কোটের পর থেকে বন্ধ কোট খোঁজে, পথে \ পেলে পরের অক্ষরটি ", \ বা n কি না যাচাই করে; আর unescape token-এর লেখাকে আসল মানে বদলায়। Token-এ source-এর লেখা হুবহু থাকে, escape-সহ (নকশা-সিদ্ধান্ত ৫)। একটি বাস্তব run:
print("মোট: \"৳ 996\"\nধন্যবাদ");~/haat $ python haat.py run receipt.haat
মোট: "৳ 996"
ধন্যবাদ
~/haat $ python haat.py tokens receipt.haat # first lines
1:1 PRINT print
1:6 LPAREN (
1:7 STRING "মোট: \"৳ 996\"\nধন্যবাদ"
1:32 RPAREN )
~/haat $ python haat.py dis receipt.haat
== <main> (arity 0, locals 0) ==
0 CONST 0 ; "মোট: \"৳ 996\"\nধন্যবাদ"
1 PRINT
2 CONST 1 ; ()
3 RETURN
সত্যিকারের run (Haat reference, CPython 3.14.4; vm দিয়েও একই দুই লাইন)। STRING token শুরু কলাম ৭-এ, আর পরের ) কলাম ৩২-এ: token-এর লেখা ২৫টি code point (দুই কোট, ৩টি escape-এর ৬টি অক্ষর, বাকি বাংলা ও অন্য অক্ষর)। Reference কলাম গোনে code point ধরে (নকশা-সিদ্ধান্ত ১), তাই একটি বাংলা code point এক কলাম। Bytecode-এ পুরো string একটি constant, CONST 0; disassembler দেখানোর সময় আবার escape করে ছাপে।
এবার তিনটি error, যা কলাম গোনার নিয়ম আর type-এর নিয়ম দুটিই দেখায়:
~/haat $ cat col.haat
let shop = "বাজারঘর"; let n = shop + 1;
~/haat $ python haat.py run col.haat
1:38: error: type mismatch: expected Str, found Int
~/haat $ cat cmp.haat
let x = "চাল" < "ডাল";
~/haat $ python haat.py run cmp.haat
1:9: error: type mismatch: expected Int, found Str
1:17: error: type mismatch: expected Int, found Str
~/haat $ cat tab.haat
print("ট্যাব \t চাই");
~/haat $ python haat.py run tab.haat
1:14: error: unknown escape sequence '\t'
সত্যিকারের run (vm-এও হুবহু একই বার্তা)। প্রথমটি: 1 আছে কলাম ৩৮-এ, code point গুনলে। Byte গুনলে কলাম হতো ৫২ (“বাজারঘর”-এর ৭টি code point বাড়তি ১৪ byte নেয়)। যে editor byte গোনে, সে ভুল জায়গায় দাগ দিত। দ্বিতীয়টি: < শুধু Int চায়, আর reference প্রতিটি ভুল operand আলাদা জানায়। তৃতীয়টি: Haat v1-এ শুধু তিনটি escape; \t নেই, আর lexer প্রথম error-এই থামে (নকশা-সিদ্ধান্ত ২)। কলাম ১৪: print(" ৭টি অক্ষর, “ট্যাব” ৫টি code point (ট ্ য া ব), তারপর একটি space, তারপর \.
শেষে সবচেয়ে শিক্ষণীয় run. নিচের ফাইলে দুটি লাইনে “বড়ো” একবার একক ড় দিয়ে, একবার ড + নুক্তা দিয়ে লেখা (অংশ ৭-এর typed আর other):
~/haat $ cat nukta.haat
// বাজারঘর: একই দেখতে দুটি লেখা
let a = "বড়ো";
let b = "বড়ো";
print(a + " / " + b);
print(a == b);
print(a != b);
~/haat $ python haat.py run nukta.haat
বড়ো / বড়ো
false
true
সত্যিকারের run, দুই back end-এই একই। Reference-এর == Python-এর str তুলনা, অর্থাৎ code point ধরে; কোনো normalization নেই। tokens চালালে দেখা যায় প্রথম string-এর পরের ; কলাম ১৪-এ, দ্বিতীয়টির ১৫-এ: চোখে এক লাইন, ভেতরে এক code point বেশি। এটি bug নয়, একটি নকশা-সিদ্ধান্ত, আর তার বিকল্পগুলো ভাবনার প্রশ্ন ৩-এ।
Editor-এর দিক থেকে একটি বাস্তব জট: Language Server Protocol (LSP, editor আর ভাষার tool-এর মধ্যে কথা বলার মান) দীর্ঘদিন কলামকে UTF-16 code unit-এ গুনত; 3.17 version থেকে client আর server আলোচনা করে UTF-8, UTF-16 বা UTF-32 বেছে নিতে পারে। বাংলা লেখায় UTF-16 আর code point সমান, কিন্তু emoji থাকলে Haat-এর কলাম আর editor-এর কলাম আলাদা হবে; Haat-এর জন্য language server বানালে (পর্ব ৮০) এই রূপান্তর লাগবে।
আরও গভীরে: UTF-8 এখন এত প্রচলিত যে নতুন ভাষা আর runtime-গুলো ভেতরেও UTF-8 রাখছে: Rust আর Go শুরু থেকেই, আর Swift 5 তার native string-এর ভেতরের রূপ UTF-16 থেকে UTF-8-এ বদলেছে বলে Swift-এর প্রকাশিত নথিতে জানা যায়। পুরোনো UTF-16 ভাষাগুলো উল্টো দিক থেকে মানিয়ে নিচ্ছে, যেমন Java 18 থেকে ডিফল্ট charset UTF-8 (JEP 400). Byte-স্তরের দ্রুততার দিকেও গবেষণা আছে: Lemire আর সহকর্মীদের SIMD-ভিত্তিক UTF-8 যাচাইয়ের কাজ (simdutf) এক নির্দেশে অনেক byte একসঙ্গে পরীক্ষা করে, আর কয়েকটি বড় runtime এমন কৌশল গ্রহণ করেছে বলে জানা যায়।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:
- U+09AC-কে UTF-8-এ লিখুন। ৩ byte-এর ছাঁচ, বিট ৪ + ৬ + ৬: E0 A6 AC.
- Code point আর code unit-এর পার্থক্য? Code point Unicode-এর নম্বর; code unit encoding-এর টুকরো। UTF-16-এ U+FFFF-এর ওপরের code point দুটি unit নেয়।
- C-র
strlenবাংলা লেখায় কী গোনে? Byte; UTF-8-এ প্রতিটি বাংলা code point ৩ byte, তাই “বাজারঘর”-এ 21. - Java-তে String immutable কেন? নিরাপদ ভাগাভাগি, hash cache, thread-safety আর string pool; দাম হলো loop-এ জোড়া দেওয়ার খরচ, সমাধান
StringBuilder. - NFC আর NFD কী? NFD সব ভাঙে, NFC ভেঙে আবার জোড়ে; তুলনার আগে দুই দিকই একই রূপে আনতে হয়।
১০ · AI-এর যুগে string আর Unicode
String-এর প্রশ্নে AI assistant প্রায়ই এক ভাষার নিয়ম অন্য ভাষায় চাপায়, আর বাংলা লেখার খুঁটিনাটিতে ভুল সবচেয়ে বেশি। এই বিষয়ে বারবার দেখা ভুল:
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
“length অক্ষর গোনে” বলা, ভাষা উল্লেখ না করে | ভাষা আর version ধরে চালানো; বাংলা, যুক্তাক্ষর আর emoji দিয়ে পরীক্ষা |
| বাংলা code point বা UTF-8 byte স্মৃতি থেকে লেখা, প্রায়ই ভুল | unicodedata.name, ord, str.encode দিয়ে প্রতিটি সংখ্যা মেলানো |
s[::-1] বা split("") দিয়ে উল্টানো, s[:n] দিয়ে কাটা | “ক্ষমা” আর emoji দিয়ে চালিয়ে দেখা; grapheme ধরে কাটার API ব্যবহার |
| Normalization ছাড়া খোঁজা বা তুলনা, অথবা “NFC-তে ড় একটি code point” দাবি | একক আর ভাঙা দুই রূপ দিয়ে test; is_normalized দেখা |
| Grapheme-এর সংখ্যা নিশ্চিত বলে দেওয়া | Unicode আর লাইব্রেরির version জিজ্ঞেস করা; দুটি বাস্তবায়নে চালিয়ে তুলনা |
| “UTF-8 আর UTF-16-এ sort একই ক্রম দেয়” বলা | U+FFFD আর একটি emoji দিয়ে দুই ভাষায় differential test |
AI-কে ভালোভাবে কাজে লাগানোর উপায়: ভাষা, version আর কোন একক গুনতে চান তা বলে দেওয়া, আর প্রতিটি সংখ্যা কোন run থেকে যাচাই করবেন তা জিজ্ঞেস করা।
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১C-র শূন্য-শেষ string-কে কেউ কেউ “সবচেয়ে দামি এক byte-এর ভুল” বলেন। সিদ্ধান্তটি কি তখন ভুল ছিল, আর আজ ভাষাগুলো কী শিখেছে?
১৯৭০-এর দশকের শুরুতে PDP-11-এর মতো যন্ত্রে মেমরি ছিল কয়েক কিলোবাইট, আর প্রতিটি byte হিসাব করে খরচ হতো। Ritchie-র বর্ণনা অনুযায়ী BCPL প্রথম ঘরে দৈর্ঘ্য রাখত, যা ৮ বা ৯ বিটে সীমাবদ্ধ ছিল; B আর C শেষে একটি চিহ্ন রেখে সেই সীমা তুলে দেয়, আর তাঁদের অভিজ্ঞতায় চিহ্নটি ব্যবহারে বেশি সুবিধাজনকও ছিল। একটি pointer আর একটি loop দিয়ে string-এর সব কাজ চলে, আলাদা struct লাগে না, আর C-র “ভাষা ছোট, যন্ত্রের কাছাকাছি” দর্শনের সঙ্গে এটি মেলে। সেই প্রেক্ষাপটে সিদ্ধান্তটি যুক্তিসংগত ছিল।
সমস্যা দেখা দিল পরে, যখন program বড় হলো আর network-এর মাধ্যমে অচেনা ইনপুট আসতে লাগল। দৈর্ঘ্য string-এর ভেতরে নেই বলে strcpy, strcat, gets-এর মতো function জানতেই পারে না গন্তব্যের buffer কত বড়। ফলে buffer overflow, যা বহু দশক ধরে নিরাপত্তা-ত্রুটির বড় উৎস। দৈর্ঘ্য জানতে বারবার হাঁটার খরচও আছে: একটি loop-এর শর্তে strlen ডাকলে O(n) কাজ O(n²) হয়ে যায়। Poul-Henning Kamp ২০১১ সালে ACM Queue-তে এই খরচগুলো একসঙ্গে বিবেচনা করে সিদ্ধান্তটিকে “সবচেয়ে দামি এক byte-এর ভুল” বলেন; তিনি দৈর্ঘ্যসহ pointer-কে বিকল্প হিসেবে দেখান।
পরের ভাষাগুলো সেই শিক্ষা নিয়েছে। Java আর C# string-কে দৈর্ঘ্যসহ object বানিয়েছে, আর সীমার বাইরে গেলে exception. Go আর Rust ঠিকানা আর দৈর্ঘ্য একসঙ্গে বহন করে, আর index-এ সীমা যাচাই করে। C++17 আনে std::string_view, C++20 std::span, যাতে পুরোনো C-ধাঁচের কোডও দৈর্ঘ্য বহন করতে পারে। C নিজেও ধীরে বদলেছে: C11 gets সরিয়ে দিয়েছে, আর ঐচ্ছিক Annex K-তে সীমা-যাচাই করা function রেখেছে, যদিও সেগুলো ব্যাপকভাবে বাস্তবায়িত হয়নি বলে সমালোচনা আছে।
মূল উপলব্ধি: একটি data representation-এর সিদ্ধান্ত তার সময়ের সীমা থেকে আসে, কিন্তু তার দাম দিতে হয় পরের প্রজন্মকে। আজকের নকশার নিয়ম: দৈর্ঘ্য তথ্যের অংশ হিসেবে বহন করুন, আর সীমা যাচাই ভাষা বা library-কে দিন, প্রোগ্রামারের স্মৃতিকে নয়।
প্র ০২Java আর JavaScript কেন UTF-16-এ আটকে আছে, আর নতুন ভাষাগুলো কেন UTF-8 বেছে নিচ্ছে?
Unicode-এর প্রথম সংস্করণগুলোর অনুমান ছিল, পৃথিবীর সব প্রচলিত লিপি ৬৫,৫৩৬টি ঘরে আঁটবে। তাই একটি অক্ষর মানে একটি ১৬-বিট সংখ্যা: সরল, প্রতিটি অক্ষর সমান মাপের, index এক ধাপে। ১৯৯০-এর দশকের মাঝামাঝি নকশা হওয়া Java আর JavaScript, আর তার আগে Windows NT, এই মডেল গ্রহণ করে; Java-র char ১৬ বিট, JavaScript-এর string ১৬-বিট unit-এর সারি। সেই সময়ে এটি দূরদর্শী সিদ্ধান্তই মনে হয়েছিল, কারণ অনেক পুরোনো সিস্টেম তখনো ৮-বিটের আঞ্চলিক code page-এ আটকে ছিল।
Unicode 2.0 (১৯৯৬) পরিসর বাড়িয়ে U+10FFFF পর্যন্ত নেয়, আর U+FFFF-এর ওপরের অক্ষরগুলোর জন্য surrogate pair আনে। তখন UTF-16 আর “এক unit এক অক্ষর” রইল না, কিন্তু ভাষাগুলোর length, charAt, index আর string তুলনার অর্থ বদলানো সম্ভব ছিল না: ওয়েবের কোটি কোটি পাতা আর Java-র বিশাল কোডভান্ডার পুরোনো অর্থের ওপর দাঁড়িয়ে। ফলে দুই ভাষাই পাশে নতুন API যোগ করেছে (Java 5-এ code point method, ES2015-এ codePointAt আর for…of, ES2024-এ isWellFormed), পুরোনোটি রেখে দিয়ে। এই পর্বের JavaScript run-এ .length 2 আর slice-এ আধখানা জোড়া এই ইতিহাসেরই ফল।
এর মধ্যে UTF-8 ওয়েব, ফাইল আর network protocol-এর প্রধান encoding হয়ে ওঠে, কারণ এটি ASCII-সামঞ্জস্যপূর্ণ, byte order-এর প্রশ্ন নেই, আর ইংরেজি-প্রধান লেখায় জায়গা কম লাগে। ভেতরে UTF-16 রাখা ভাষাকে তাই প্রতিটি ইনপুট-আউটপুটে রূপান্তর করতে হয়। নতুন ভাষা Go (২০০৯) আর Rust (১.০, ২০১৫) শুরু থেকেই ভেতরে UTF-8 রাখে; Swift 5 তার ভেতরের রূপ UTF-8-এ বদলেছে। দাম হলো index: UTF-8-এ i-তম code point পেতে হাঁটতে হয়, তাই এই ভাষাগুলো integer index সরাসরি দেয় না বা byte-index দেয়।
বাংলার জন্য একটি সূক্ষ্ম দিক আছে: বাংলা code point UTF-16-এ ২ byte, UTF-8-এ ৩ byte. শুধু বাংলা লেখায় তাই UTF-16 ছোট; HTML বা JSON-এর মতো ASCII-মেশানো লেখায় প্রায়ই UTF-8 ছোট বা কাছাকাছি।
মূল উপলব্ধি: একটি ভাষার মৌলিক type-এর অর্থ একবার প্রকাশ হলে আর বদলানো যায় না; ভাষা শুধু পাশে নতুন API যোগ করতে পারে। তাই নতুন ভাষা নকশায় string-এর একক আর encoding বেছে নেওয়া প্রথম দিনের সবচেয়ে টেকসই সিদ্ধান্তগুলোর একটি।
প্র ০৩Haat-এর == কি normalization করে তুলনা করা উচিত? Lexer-এ, runtime-এ, নাকি কোথাও নয়?
অংশ ৯-এর run দেখিয়েছে, Haat reference-এ চোখে এক দুটি “বড়ো” ==-তে false. তিনটি নকশা সম্ভব, প্রতিটির যুক্তি আছে।
কোথাও নয় (বর্তমান অবস্থা): Python, Java, JavaScript, Rust, Go সবাই এই পথে; == code point বা code unit ধরে তুলনা করে। সুবিধা: সরল, দ্রুত, অনুমানযোগ্য, আর তুলনাটি একটি equivalence relation হিসেবে সহজে প্রমাণযোগ্য। Normalization চাইলে প্রোগ্রামার স্পষ্ট করে ডাকেন। অসুবিধা: যে প্রোগ্রামার Unicode-এর খুঁটিনাটি জানেন না, তাঁর খোঁজ নিঃশব্দে ব্যর্থ হয়।
Lexer-এ: compiler source ফাইলের প্রতিটি string literal-কে NFC-তে আনে। তাহলে nukta.haat-এর দুটি literal সমান হবে। কিন্তু চলার সময় বাইরে থেকে আসা লেখা (ভবিষ্যতে ইনপুট পড়ার ব্যবস্থা এলে) normalization ছাড়াই আসবে, তাই সমস্যার অর্ধেক থেকে যায়; আর প্রোগ্রামার যদি ইচ্ছে করে ভাঙা রূপ রাখতে চান (যেমন normalization নিয়ে একটি test লিখতে), তিনি পারবেন না। Swift এই প্রশ্নে আরও এগিয়েছে: তার String-এর == canonical equivalence মেনে চলে বলে Swift-এর documentation বলে, অর্থাৎ ভাষাই সমতা “চোখে এক” অর্থে সংজ্ঞায়িত করে (এখানে চালানো হয়নি)।
Runtime-এ: == প্রতিবার দুই দিককে normalize করে তুলনা করে, অথবা প্রতিটি string তৈরির সময়েই NFC-তে রাখা হয়। প্রথমটি প্রতিটি তুলনায় খরচ বাড়ায়; দ্বিতীয়টি জোড়া দেওয়ার পরেও normalization চায়, কারণ দুটি NFC string জুড়লে ফল NFC না-ও হতে পারে (যেমন একটির শেষে এ-কার আর অন্যটির শুরুতে আ-কার)। Hash-ও normalization-এর পরে হিসাব করতে হবে, নইলে dictionary-তে দুটি সমান key দুই ঘরে পড়বে।
একটি শিক্ষণ-ভাষা হিসেবে Haat-এর জন্য লেখকের মত: == code point ধরেই থাকুক, কারণ তা সংজ্ঞায় সহজ আর পর্ব ৫৬-এর interpreter ও পর্ব ৫৯-এর VM-এ এক লাইনের কাজ; তার সঙ্গে একটি স্পষ্ট built-in (ধরুন nfc(s)) আর lint warning যোগ করা যায়, যা source-এ non-NFC literal দেখলে সতর্ক করে।
মূল উপলব্ধি: “সমতা” কী, সেটি একটি ভাষা-নকশার সিদ্ধান্ত, স্বতঃসিদ্ধ নয়। সরলতা আর অনুমানযোগ্যতা বনাম মানুষের প্রত্যাশা, এই আপসে বেশিরভাগ ভাষা প্রথমটি বেছে নিয়ে normalization-কে স্পষ্ট API করেছে।
প্র ০৪Compiler-এর error message-এ “কলাম” কী গোনা উচিত: byte, UTF-16 unit, code point নাকি grapheme?
প্রশ্নটি খুঁটিনাটি মনে হলেও বাংলা বা emoji থাকা source ফাইলে এটি সরাসরি ব্যবহারকারীর অভিজ্ঞতা ঠিক করে। অংশ ৯-এর run-এ 1 literal-টি code point গুনলে কলাম ৩৮-এ, byte গুনলে ৫২-এ। Error message আর editor-এর দাগ একই এককে না হলে ভুল জায়গা দেখায়।
Byte: GCC আর Clang ঐতিহ্যগতভাবে কলামকে byte ধরে গোনে বলে জানা যায় (GCC-তে -fdiagnostics-column-unit নামে একটি option আছে, যা “display” বা “byte” বেছে নিতে দেয়; বিস্তারিত version-ভেদে আলাদা, এখানে চালানো হয়নি)। Byte গোনা সবচেয়ে সস্তা আর encoding-নিরপেক্ষ, কিন্তু মানুষের কাছে অর্থহীন। UTF-16 unit: LSP দীর্ঘদিন এটিই ডিফল্ট রেখেছিল, কারণ VS Code-এর মতো editor JavaScript-এ লেখা আর JavaScript string UTF-16; 3.17 থেকে আলোচনা করে অন্য একক বেছে নেওয়া যায়। Code point: Haat reference এটি বেছে নিয়েছে (নকশা-সিদ্ধান্ত ১); Python-এর str index-এর সঙ্গে মেলে, আর বাংলায় UTF-16-এর সঙ্গেও মেলে। Grapheme বা প্রদর্শনের প্রস্থ: মানুষের চোখে সবচেয়ে সঠিক, কারণ “ক্ষ”-কে এক ঘর ধরে; কিন্তু হিসাব Unicode-এর version-এর ওপর নির্ভর করে (অংশ ৬-এর ২ বনাম ৩), আর ফন্ট ও terminal-ভেদে প্রস্থ বদলায়, তাই পুনরুৎপাদনযোগ্য নয়।
একটি tab-ও একই প্রশ্ন তোলে: Haat-এ tab এক কলাম, কিন্তু editor হয়তো ৪ বা ৮ ঘর দেখায়। Rust-এর compiler-এর মতো কিছু tool error-এর নিচে ^ দিয়ে দাগ দেওয়ার সময় প্রদর্শনের প্রস্থ হিসাব করে, কিন্তু সংখ্যাটি আলাদা এককে রাখে বলে জানা যায়।
ভালো নকশা তাই দুই স্তরের: ভেতরে একটি নির্ধারিত, পুনরুৎপাদনযোগ্য একক (byte offset বা code point), যা tool-গুলো একে অপরের সঙ্গে আদান-প্রদান করে; আর মানুষকে দেখানোর সময় source লাইনটি ছাপিয়ে তার নিচে দাগ, যাতে সংখ্যা না গুনেও জায়গা চেনা যায়। Haat-এর জন্য পর্ব ৫০-এ (ভালো diagnostic message) এই দ্বিতীয় স্তর যোগ করার সুযোগ আসবে।
মূল উপলব্ধি: “কলাম” কোনো স্বাভাবিক সংখ্যা নয়, একটি চুক্তি। Compiler, editor আর language server-কে একই চুক্তি মানতে হয়; আর মানুষের জন্য সংখ্যার চেয়ে দাগ দেওয়া source লাইন বেশি নির্ভরযোগ্য।
প্র ০৫Unicode identifier আর বাংলা keyword-ওয়ালা প্রোগ্রামিং ভাষা: সুবিধা কী, আর কী কী ঝুঁকি সামলাতে হবে?
আজকের অনেক ভাষা non-ASCII identifier অনুমোদন করে: Python 3 (PEP 3131), Java (শুরু থেকেই Unicode letter), JavaScript, Rust (১.৫৩ থেকে, RFC 2457 অনুযায়ী বলে জানা যায়) আর Go. অর্থাৎ মোট = দাম * পরিমাণ লেখা Python-এ বৈধ হতে পারে। সুবিধা স্পষ্ট: নতুন শিক্ষার্থী, বিশেষ করে যাঁরা ইংরেজিতে স্বচ্ছন্দ নন, নিজের ভাষায় ধারণাগুলো নাম দিতে পারেন; বাংলা ব্যবসার নিয়ম (বাজারঘরের ছাড়ের হিসাব) কোডে প্রায় হুবহু লেখা যায়।
কিন্তু বাস্তবায়নে তিনটি প্রশ্ন সামলাতে হয়। এক, কোন code point identifier-এ চলবে? Unicode এর জন্য UAX #31 নির্দেশিকা দেয় (XID_Start, XID_Continue বৈশিষ্ট্য)। বাংলা আকার বা হসন্ত শুরুতে বসতে পারে না, মাঝে পারে; ZWJ আর ZWNJ বাংলা বানানের জন্য দরকারি, অথচ অদৃশ্য, তাই সেগুলো নিয়ে আলাদা নিয়ম লাগে। দুই, normalization: একক ড় আর ড + নুক্তা দিয়ে লেখা দুটি নাম একই variable কি না। Python NFKC করে এক বানায়; Rust NFC করে। না করলে চোখে এক দুটি নাম দুটি আলাদা variable, যা ভয়ংকর bug. তিন, নিরাপত্তা: বিভিন্ন লিপির দেখতে-এক অক্ষর (homoglyph) দিয়ে দুটি আলাদা নাম বানিয়ে code review-তে ধোঁকা দেওয়া যায়; ২০২১ সালের “Trojan Source” গবেষণা (Boucher ও Anderson) দেখিয়েছিল bidirectional control character দিয়ে কোডের দৃশ্যমান রূপ আর আসল অর্থ আলাদা করা সম্ভব, আর এর পর অনেক compiler ও editor সতর্কবার্তা যোগ করে। এই আলোচনা প্রতিরোধমূলক: tool-কে সন্দেহজনক অক্ষর চিহ্নিত করতে হবে।
বাংলা keyword (যেমন যদি, নইলে) আরেক ধাপ: শুধু lexer-এর keyword টেবিল বদলালেই কারিগরি কাজ শেষ, কিন্তু library, documentation, error message আর সম্প্রদায়ের পুরো বাস্তুতন্ত্র ইংরেজিতে, তাই এমন ভাষা মূলত শিক্ষার কাজে লাগে। Haat ইচ্ছে করে ASCII identifier রেখেছে, যাতে lexer আর এই পর্বের সব জট আলাদা করে শেখা যায়। পর্ব ৭৯-এ (DSL নকশা) বাংলা keyword-ওয়ালা একটি ছোট বাজারঘর-DSL নকশা করার সুযোগ থাকবে।
মূল উপলব্ধি: Unicode identifier একটি lexer-এর ছোট পরিবর্তন মনে হলেও আসলে তিনটি নকশা-প্রশ্ন: কোন অক্ষর বৈধ, কখন দুটি নাম সমান, আর চোখের ধোঁকা কীভাবে ঠেকানো যায়। তিনটির উত্তর না দিয়ে দরজা খুললে সুবিধার চেয়ে ঝুঁকি বেশি।
অনুশীলন
প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি সংখ্যা সত্যিকারের Python, JavaScript বা Haat reference run দিয়ে মেলানো।
-
নকশা ও বাস্তবায়ন — Haat-এর বর্ধিত রূপ
\u{…}escape: Haat v1-এ শুধু\",\\,\nআছে। (ক)\u{9AC}-এর মতো code point escape-এর নিয়ম লিখুন: কয়টি hex অঙ্ক, কোন নম্বর নিষিদ্ধ, error message কী। (খ) Reference-এরunescape-এর ধাঁচে একটি Python function লিখে\u{9AC}\u{9BE},\u{1F6D2},\u{D83D},\u{110000}আর\u{}দিয়ে পরীক্ষা করুন। (গ) এই escape থাকলে অংশ ৭-এর normalization সমস্যা দেখানো কি সহজ হয়?(ক) নিয়ম (Rust আর JavaScript-এর
\u{…}-এর মতো):\u{-এর পরে ১ থেকে ৬টি hex অঙ্ক, তারপর}. মান U+10FFFF-এর বেশি হলে, বা D800–DFFF (surrogate) হলে error, কারণ সেগুলো আলাদা চিহ্ন নয় (অংশ ৫)। অঙ্ক না থাকলে, ৬টির বেশি হলে বা}না পেলেbad unicode escape; পরিসরের ভুলেinvalid code point U+XXXX. Error-এর অবস্থান\-এর কলাম, Haat-এর বাকি escape-error-এর মতো।(খ) লেখকের lab-এ চালানো রূপের মূল অংশ (
unescape-এর loop-এ\-এর পরেuএলে এই function ডাকা হয়;LexErrorএকটি সাধারণ exception class):HEX = "0123456789abcdefABCDEF" def unicode_escape(body, j, col): # body[j] == "\\", body[j+1] == "u" if body[j + 2:j + 3] != "{": raise LexError(f"{col + j}: bad unicode escape") end = body.find("}", j + 3) digits = body[j + 3:end] if end != -1 else "" if not (1 <= len(digits) <= 6 and all(d in HEX for d in digits)): raise LexError(f"{col + j}: bad unicode escape") cp = int(digits, 16) if cp > 0x10FFFF or 0xD800 <= cp <= 0xDFFF: raise LexError(f"{col + j}: invalid code point U+{cp:04X}") return chr(cp), end + 1 # the character and the next index\u{9AC}\u{9BE} -> 'বা' code points: ['U+09AC', 'U+09BE'] Tk \u{9F3} 996 -> 'Tk ৳ 996' code points: ['U+0054', 'U+006B', 'U+0020', 'U+09F3', 'U+0020', 'U+0039', 'U+0039', 'U+0036'] \u{1F6D2} -> '🛒' code points: ['U+1F6D2'] \u{D83D} -> error 8: invalid code point U+D83D \u{110000} -> error 8: invalid code point U+110000 \u{} -> error 8: bad unicode escape \u{9AC -> error 8: bad unicode escapeসংখ্যা ৮ এখানে পরীক্ষার জন্য ধরা কলাম। Scanner-এর দিকেও (
scan_string) একটি বদল লাগে:\-এর পরেuএলে সেটিকে বৈধ escape-এর শুরু ধরা, নইলে আজকেরunknown escape sequenceআসবে। (গ) হ্যাঁ:"ব\u{9DC}\u{9CB}"আর"ব\u{9A1}\u{9BC}\u{9CB}"source-এ চোখে আলাদা, তাই কোন রূপ কোনটি তা স্পষ্ট, আর অদৃশ্য ZWJ/ZWNJ-ও (\u{200D}) দৃশ্যমান করে লেখা যায়। এজন্যই বহু ভাষা এই escape রাখে। -
প্রমাণ — UTF-8 byte-এর ক্রম = code point-এর ক্রম: দুটি Unicode scalar value a < b হলে প্রমাণ করুন, তাদের UTF-8 byte-সারিকে lexicographic (অভিধানের মতো, প্রথম অমিল byte ধরে) তুলনা করলেও UTF-8(a) < UTF-8(b). তারপর দেখান UTF-16-এ কেন এটি খাটে না।
প্রমাণের রূপরেখা। ধরুন n(x) = x-এর UTF-8 byte-সংখ্যা (১ থেকে ৪), যা x-এর পরিসর দিয়ে ঠিক হয়, আর পরিসরগুলো ক্রমানুসারে সাজানো; তাই a < b হলে n(a) ≤ n(b).
- n(a) < n(b): প্রথম byte-এর ওপরের বিটগুলো দেখুন। ১ byte-এর প্রথম byte
0xxxxxxx(≤ 0x7F), ২ byte-এর110xxxxx(0xC0–0xDF), ৩ byte-এর1110xxxx(0xE0–0xEF), ৪ byte-এর11110xxx(0xF0–0xF7). এই পরিসরগুলো ক্রমানুসারে আর পরস্পর-বিচ্ছিন্ন, তাই প্রথম byte-ই UTF-8(a) < UTF-8(b) ঠিক করে দেয়। - n(a) = n(b) = k: দুটি সারির ছাঁচের স্থির বিট (
1110,10ইত্যাদি) একই জায়গায় একই। বাকি x-বিটগুলো ওপর থেকে নিচে পড়লে ঠিক a আর b-এর k-byte রূপের বিট পাওয়া যায় (অংশ ৫-এর stepper-এ কাটা ৪ + ৬ + ৬)। তাই প্রথম যে byte-এ অমিল, তার প্রথম অমিল বিটটি a আর b-এর বাইনারি রূপের প্রথম অমিল বিট; a < b বলে সেখানে a-তে 0, b-তে 1. - দুই ক্ষেত্রেই UTF-8(a) < UTF-8(b). ∎
UTF-16-এ কেন নয়: U+FFFD একটি unit, FFFD; U+1F6D2 দুটি unit, D83D DED2. প্রথম unit তুলনায় D83D < FFFD, অথচ 0x1F6D2 > 0xFFFD. সমস্যার মূল: surrogate-এর পরিসর D800–DFFF বসে BMP-র E000–FFFF অংশের নিচে, তাই ধাপ ১-এর মতো “প্রথম unit-এর পরিসর ক্রম রক্ষা করে” যুক্তি ভেঙে পড়ে। অংশ ৭-এর Python run (
utf-16-be: … True) আর অংশ ৬-এর JavaScript run (sort() puts first: 1f6d2) ঠিক এটিই দেখিয়েছে। - n(a) < n(b): প্রথম byte-এর ওপরের বিটগুলো দেখুন। ১ byte-এর প্রথম byte
-
হিসাব — হাতে encode আর গণনা: (ক) টাকার চিহ্ন ৳ (U+09F3)-কে UTF-8-এ লিখুন। (খ) U+1F6D2-এর UTF-16 surrogate pair বের করুন। (গ) “টাকা” শব্দের UTF-8 byte, UTF-16 unit, code point আর grapheme-এর সংখ্যা বলুন।
(ক) 0x09F3 =
0000 1001 1111 0011; ৪ + ৬ + ৬ করে কাটলে0000,100111,110011; ছাঁচে বসালে11100000 10100111 10110011= E0 A7 B3. লেখকের lab-এreceipt.haatফাইলের byte dump-এ ৳-এর জায়গায় ঠিক এই তিন byte (octal-এ 340 247 263) পাওয়া গেছে।(খ) 0x1F6D2 − 0x10000 = 0xF6D2 = ২০ বিটে
0000111101 1011010010. ওপরের ১০ বিট 0x03D, তাই D800 + 03D = D83D; নিচের ১০ বিট 0x2D2, তাই DC00 + 2D2 = DED2. অংশ ৫-এর encoder আর অংশ ৬-এরcharCodeAtদুটিইD83D DED2দিয়েছে।(গ) “টাকা” = ট (099F) + া (09BE) + ক (0995) + া (09BE): ৪টি code point; সব BMP-তে, তাই UTF-16 unit-ও ৪; UTF-8 byte ৪ × ৩ = ১২; grapheme দুটি, “টা” আর “কা”, কারণ আকার spacing mark হিসেবে আগের অক্ষরের সঙ্গে যায়। Python run-এ code point 4 আর UTF-8 12 পাওয়া গেছে।
-
ভুল খুঁজুন — উল্টানো আর কাটা: বাজারঘরের একজন ডেভেলপার একটি মজার ফিচারের জন্য JavaScript-এ নাম উল্টাতে লিখলেন
s.split("").reverse().join(""), আর SMS-এর জন্য Python-এ নাম ছোট করলেনname[:2]দিয়ে।s = "বাজার🛒"আরname = "ক্ষমা"দিলে কী হবে? ঠিক করার উপায় কী?লেখকের যন্ত্রে সত্যিকারের run: তিন রকম উল্টানো Node.js 24-এ (
JSON.stringifyদিয়ে ছাপা, যাতে ভাঙা unit দেখা যায়), আর শেষ লাইন CPython 3.14.4-এprint(repr(name[:2])):split reversed : "\uded2\ud83dরাজাব" well formed? false [...s] reversed: "🛒রাজাব" well formed? true graphemes rev. : "🛒রজাবা" 'ক্'ভুল ১:
split("")UTF-16 unit ধরে ভাঙে, তাই surrogate pair-এর দুই অর্ধেক উল্টো ক্রমে বসে, আর ফল আর বৈধ লেখাই নয় (isWellFormed= false); পর্দায় দুটি U+FFFD-এর মতো চিহ্ন আসবে। ভুল ২:[...s]code point ধরে উল্টায়, তাই emoji ঠিক থাকে, কিন্তু কার-চিহ্ন ভুল অক্ষরে গিয়ে বসে: “বাজার” হয়ে যায় “রাজাব”, যা দেখতে একটি শব্দ হলেও ভুল; ঠিক উত্তর grapheme উল্টানো, “রজাবা”. ভুল ৩: Python-এরname[:2]দুটি code point কাটে, ক আর হসন্ত, তাই SMS-এ যায় ঝুলন্ত “ক্”. সমাধান: মানুষের চোখের অক্ষর ধরে কাজ করতে grapheme segmentation (JavaScript-এIntl.Segmenter, Java-য়BreakIterator, Python-এ ICU-ভিত্তিক তৃতীয়-পক্ষের লাইব্রেরি) ব্যবহার করুন, আর SMS-এর মাপ যদি byte বা unit-এ হয়, তাহলে সেই এককে মেপে grapheme-এর সীমায় কাটুন।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি code point (যেমন U+09AC) হাতে UTF-8-এ লেখার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Code point কোন পরিসরে পড়ে দেখে byte-সংখ্যা ঠিক করা
- Code point-কে বাইনারিতে লেখা
- বিটগুলো ছাঁচের x-ঘরের মাপে (যেমন ৪ + ৬ + ৬) কাটা
- প্রতিটি টুকরো ছাঁচের স্থির বিটের (1110, 10, 10) পরে বসানো
- প্রতিটি byte-কে hex-এ লেখা
“ক্ষমা” শব্দটি UTF-8-এ রাখলে C17-এর strlen, Java 21-এর length() আর Python 3-এর len() কী ফেরত দেবে?
- 2, 2, 2
- 5, 5, 5
- 15, 5, 5
- 15, 15, 15
U+09AC (ব)-এর UTF-8 encoding কোনটি?
- 09 AC
- E0 A6 AC
- C2 AC
- F0 80 A6 AC
JavaScript-এ "🛒".length (শপিং-ট্রলি, U+1F6D2) 2 কেন?
- Emoji সবসময় দুটি অক্ষর দিয়ে তৈরি হয়
- JavaScript string UTF-8 byte গোনে
- এর ভেতরে একটি অদৃশ্য ZWJ আছে
- String UTF-16 unit-এর সারি, আর U+FFFF-এর ওপরের code point দুটি unit নেয়
Python 3-এ a = "ব" + chr(0x09DC) + "ো" আর b = "ব" + chr(0x09A1) + chr(0x09BC) + "ো". কোনটি সঠিক?
a == bমিথ্যা, কিন্তু NFC-তে আনার পরে সমানa == bসত্য, কারণ Python নিজে থেকে normalize করে- NFC-তে a অপরিবর্তিত থাকে, তাই NFC-র পরেও অসমান
- কোনো normalization-এই দুটি সমান হয় না
Haat v1 program let x = "চাল" < "ডাল"; চালালে Haat reference কী করে?
- Code point-এর ক্রমে তুলনা করে
trueরাখে - বাংলা অভিধানের ক্রমে তুলনা করে
- দুটি type error দেয়, প্রতিটি Str operand-এর জন্য একটি
- String দুটিকে সংখ্যায় রূপান্তর করে তুলনা করে
C-র শূন্য-শেষ (NUL-terminated) string-এর তুলনায় দৈর্ঘ্যসহ রাখা string (Java object, Rust বা Go-র ঠিকানা + দৈর্ঘ্য)-এর প্রধান সুবিধা কোনটি?
- প্রতিটি string-এ মেমরি কম লাগে
- দৈর্ঘ্য এক ধাপে জানা যায়, মাঝে শূন্য রাখা যায়, আর সীমা যাচাই সম্ভব
- এতে বাংলা লেখা স্বয়ংক্রিয়ভাবে UTF-8-এ থাকে
- Length সবসময় grapheme গোনে
Haat reference lexer কলাম গোনে code point ধরে। let shop = "বাজারঘর"; let n = shop + 1; লাইনে type error-টি কলাম ৩৮-এ দেখানো হয়। যে editor UTF-8 byte ধরে কলাম গোনে, সে একই অবস্থানকে কোন কলাম বলবে?
- 38
- 45
- 59
- 52
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- চার একক: byte, code unit, code point, grapheme. ভাষা যে একককে string-এর উপাদান বলে,
lengthআর index তা-ই গোনে: “ক্ষমা” C-তে 15, Java/JavaScript/Python-এ 5, grapheme-এ 2. - মেমরি-নকশা: শেষে শূন্য (C, O(n) দৈর্ঘ্য, overflow-এর ঝুঁকি), শুরুতে দৈর্ঘ্য (Pascal), ঠিকানা + দৈর্ঘ্য (Rust, Go), header-সহ immutable object (Java, Python, JavaScript).
- UTF-8: ১–৪ byte, বাংলা ৩ byte; ছাঁচ
1110xxxx 10xxxxxx 10xxxxxx; ASCII-সামঞ্জস্য, self-synchronizing, আর byte-ক্রম = code point-ক্রম। UTF-16-এ U+FFFF-এর ওপরে surrogate pair. - Normalization: একক ড় আর ড + নুক্তা চোখে এক,
==-তে আলাদা; NFC-তে ড় দুটি code point (composition exclusion). তুলনা আর সাজানোর আগে একই রূপে আনুন; মানুষের ক্রমের জন্য collation. - Haat-এর Str:
+আর==/!=, কোনো<নেই; lexer তিনটি escape চেনে আর কলাম গোনে code point ধরে;==normalization ছাড়া, তাই দুই রূপের “বড়ো”false.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ২২ · Composite type — array, record, tuple আর unionপরবর্তী পর্বএকাধিক মান একসঙ্গে রাখার নকশা আর তাদের ঠিকানার হিসাব।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- বাংলা টাইপিং আর Unicode — অভ্র, বিজয় আর ফন্টের সমস্যাপাশের ট্র্যাকবাংলা লেখার ব্যবহারিক দিক: keyboard, ফন্ট আর ভাঙা লেখা।
- string — slicing, method আর বাংলা Unicodeপাশের ট্র্যাকPython-এর string হাতে-কলমে।
- string, template literal আর বাংলা Unicodeপাশের ট্র্যাকJavaScript-এর UTF-16 string, Segmenter আর localeCompare.