پارسال رکوردم ۲۱ هزار قدم بود 🥲 حوصله نمی‌کنم چرا هرچقدر راه میرم باز فکرم پیش پروژه‌هامه 😩

خودت را دوست داشته باش…
چون تنها کسی هستی که در همه لحظات کنار خودت بوده‌ای.
کسی که حتی یک بار هم نگفت «نمی‌آیم»، هیچ‌وقت جا نزد، هیچ‌وقت رهایت نکرد.
در سکوت آمد، شنید بی‌آن‌که قضاوت کند، ماند بی‌آن‌که شرط بگذارد.
وقتی همه دور شدند، او ماند… خودِ تو ماند.
حتی وقتی رنجاندی‌اش، تحمل کرد…
پس حالا وقتش است که قدرش را بدانی.
خودت را ببخش، خودت را در آغوش بگیر…
و با تمام وجود، خودت را دوست داشته باش — چون همیشه قوی‌ترین همراهت، خودت بوده‌ای.

روز بخیر؛

عضو std::views::zip در استاندارد ۲۳ یک نمایه (view) از عناصری را تولید می‌کند که هر یک از آنها شبیه به یک tuple هستند و هر یک از عناصر متناظر از همهٔ نمایه‌های تطبیق داده شده تشکیل شده است و کوتاه‌ترین محدوده تعداد عناصر موجود در نمایه را تعیین می‌کند. عناصر نمایهٔ خروجی، خاصیت (reference semantics) را حفظ می‌کنند، به این معنی که اگر دامنه‌های ورودی قابل تغییر (mutable) باشند، عناصر آن‌ها را می‌توان از طریق عناصر دید خروجی تغییر داد.

import std;

auto main() -> int {
    std::vector<int> first{1,2,3,4,5};
    std::vector<double> second{9,8,7,6};
    
    // Iterate over the elements of the zip view
    for (auto [a, b] : std::views::zip(first, second)) {
        // {1,9}, {2,8}, {3,7}, {4,6}
        std::cout << a << " " << b << "\n";
    }
    std::cout << "\n";
    
    // Same as above, without structured binding
    for (std::tuple<int&,double&> el : std::views::zip(first, second)) {
        // {1,9}, {2,8}, {3,7}, {4,6}
        std::cout << std::get<0>(el) << " " << std::get<1>(el) << "\n";
    }
    std::cout << "\n";
    
    std::vector<std::string> third{"label1", "label2", "label3"};
    
    // The zip view can accept one or more arguments
    for (auto [a, b, c] : std::views::zip(first, second, third)) {
        // {1,9,"label1"}, {2,8,"label2"}, {3,7,"label3"}
        std::cout << a << " " << b << " " << std::quoted(c) << "\n";
    }
    std::cout << "\n";
    
    // We can also modify the original ranges through the tuple
    for (auto [a, b, c] : std::views::zip(first, second, third)) {
        a = a + b;
        std::cout << a << " " << b << " " << std::quoted(c) << "\n";
    }
    std::cout << "\n";
    // first == {10, 10, 10, 4, 5}
    
    for (auto v : first)
        std::cout << v << " ";
    std::cout << "\n";
}

#cpp20 #cpp23 #view_zip #view #zip #چالش #سی‌روزه #رمضان #روز_بیست_دوم

بخش تخصصی دوم (به‌روز رسانی Solidity) | توابع خالص (Pure)

توابع در سالیدیتی می‌توانند به عنوان «خالص» (pure) تعریف شوند. این به این معنی است که این توابع قول می‌دهند که هیچگونه خواندن یا تغییری در وضعیت قرارداد (state) ایجاد نکنند. به طور خاص، ارزیابی یک تابع خالص در زمان کامپایل تنها با ورودی‌های آن و msg.data و بدون هیچ دانش خاصی از وضعیت فعلی بلاکچین امکان‌پذیر باشد. این بدان معناست که خواندن از متغیرهای «غیرقابل تغییر» (immutable) می‌تواند عملیاتی غیرخالص باشد.

توجه)
اگر هدف EVM کامپایلر، بیزانتيوم (Byzantium) یا جدیدتر (که حالت پیش فرض است) باشد، کد دستور STATICCALL استفاده می‌شود که تضمین نمی‌کند وضعیت خوانده نشود، اما حداقل تضمین می‌کند که تغییر نمی‌کند.

علاوه بر لیست دستورات تغییر وضعیت که در بالا توضیح داده شد، موارد زیر نیز به عنوان خواندن از وضعیت در نظر گرفته می‌شوند:

- خواندن از متغیرهای وضعیت.
- دسترسی به <address>.balance یا address(this).balance
- دسترسی به هر یک از اعضای block، tx، msg (با استثنای msg.sig و msg.data).
- فراخوانی هر تابعی که علامت خالص (pure) ندارد.
- استفاده از مونتاژ درون‌خطی که شامل برخی از کدگذاری‌ها (opcodes) است.
- توابع خالص قادرند از توابع ()revert و ()require استفاده کنند تا تغییرات وضعیتی احتمالی را برگردانند هنگامی که خطا رخ می‌دهد.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.9.0;

contract C {
    function f(uint a, uint b) public pure returns (uint) {
        return a * (b + 42);
    }
}

برگشت یک تغییر وضعیت به عنوان «تغییر وضعیت» در نظر گرفته نمی‌شود، زیرا تنها تغییراتی در وضعیت که قبلاً در کدی ایجاد شده که محدودیت «دید» (view) یا «خالص» (pure) را نداشته است، برگشت داده می‌شود و آن کد می‌تواند خطای برگشت (revert) را مدیریت کند و آن را منتقل نکند.

این رفتار همچنین با کد دستور STATICCALL مطابقت دارد.

#solidity #web3 #update #ether #اتریوم

عضو std::views::adjacent در استاندارد ۲۳ شبیه به std::views::slide عمل می‌کند، به این صورت که هر دو یک "حالت کشوئی" روی داده‌های ورودی ایجاد می‌کنند. اما در تفاوت بین آن‌ها، عضو std::views::slide زیرمجموعه‌هایی (subranges) از داده‌های ورودی ایجاد می‌کند و عضو std::views::adjacent گروه‌هایی از ارجاع (reference) به عناصر مجاور را به صورت چند‌تایی (tuple) تولید می‌کند.

به‌عبارت دیگر، std::views::adjacent به جای اینکه بخش‌هایی از داده‌های ورودی را جدا کند، به عناصر مجاور (کنار هم) به عنوان یک مجموعه نگاه می‌کند و آن‌ها را در قالب تاپل (چندتایی مرتب) در اختیار شما قرار می‌دهد. این ویژگی به شما این امکان را می‌دهد که از "بستنِدگیِ ساختاریافته" (structured binding) برای تجزیهٔ عناصر چند‌تایی (tuple) استفاده کنید. به عنوان مثال، اگر std::views::adjacent عناصر دوتایی (pair) تولید کند (که معادل std::views::pairwise است)، می‌توانید به راحتی به هر عنصر مجاور به صورت جداگانه دسترسی داشته باشید:

import std;

auto main() -> int {
    
    std::vector<int> data{1,2,3,4,5};
    
    // "sliding tuple" of references to elements
    for (std::tuple<int&,int&,int&> v : data | std::views::adjacent<3>) {
        std::println("{}, {}, {}", std::get<0>(v), std::get<1>(v), std::get<2>(v));
    }
    
    std::println("{}");
    
    // deconstructed using structured binding
    for (auto [first, second, third] : data | std::views::adjacent<3>) {
        std::println("{}, {}, {}", first, second, third);
    }
    
    std::println("{}");
    
    // std::views::adjacent<2> has an alias
    for (auto [left, right] : data | std::views::pairwise) {
        std::println("{}, {}", left, right);
        
    }
}

#cpp20 #cpp23 #view_adjacent #view #adjacent #چالش #سی‌روزه #رمضان #روز_بیست_و_سوم

بخش تخصصی دوم (به‌روز رسانی Solidity) |دریافت اتر در سالیدیتی (دریافت تابع)

در سالیدیتی، قراردادها می‌توانند با استفاده از تابعی به نام receive اتر دریافت کنند. این تابع ویژگی‌های خاصی دارد:

۱) هر قرارداد می‌تواند فقط یک تابع receive داشته باشد
۲) این تابع با کلیدواژهٔ function تعریف نمی‌شود، بلکه به صورت receive() external payable { ... } نوشته می‌شود.
۳) تابع receive نمی‌تواند ورودی‌ای داشته باشد.
۴) این تابع هیچ مقداری را برنمی‌گرداند.
۵) این تابع باید با کلیدواژه external تعریف شود تا از خارج از قرارداد قابل فراخوانی باشد.
۶) برای اینکه تابع receive بتواند اتر دریافت کند، باید با کلیدواژه payable تعریف شود.

این تابع زمانی اجرا می‌شود که اتر به صورت مستقیم به قرارداد فرستاده شود، بدون اینکه هیچ تابع دیگری در قرارداد فراخوانی شود؛ این حالت معمولاً با استفاده از متدهای send یا transfer در قراردادهای دیگر اتفاق می‌افتد. اگر تابع receive در قرارداد وجود نداشته باشد، اما یک تابع دیگر با قابلیت دریافت اتر (یعنی با کلیدواژه payable تعریف شده) به عنوان تابع پیش فرض (fallback function) وجود داشته باشد، آن تابع فراخوانی می‌شود.

همچنین اگر هیچ کدام از تابع‌های receive و fallback function با قابلیت دریافت اتر در قرارداد وجود نداشته باشد، در صورتی که اتر به صورت مستقیم به قرارداد فرستاده شود، یک خطا رخ می‌دهد و اتر به فرستنده برگردانده می‌شود. (این رفتار از نسخه ۰.۴.۰ سالیدیتی به بعد تغییر کرده است.)

در زیر می توانید نمونه‌ای از قرارداد سینک را مشاهده کنید که از این روش استفاده می‌کند.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.9.0;

// This contract keeps all Ether sent to it with no way
// to get it back.
contract Sink {
    event Received(address, uint);
    receive() external payable {
        emit Received(msg.sender, msg.value);
    }
}

نکتهٔ مهم:
- تابع receive در بدترین حالت تنها به ۲۳۰۰ واحد گاز (gas) دسترسی دارد. این مقدار گاز برای انجام کارهای زیادی کافی نیست و معمولاً فقط برای ثبت وقایع (logging) ساده کاربرد دارد.
- استفاده از تابع‌های پیش‌فرض (fallback function) با قابلیت دریافت اتر برای دریافت اتر توصیه نمی‌شود. دلیل این موضوع این است که این تابع پیش‌فرض برای هر فرستاده‌ای که قصد فراخوانی تابع اشتباهی را داشته باشد، اجرا می‌شود و جلوی آن را نمی‌گیرد.


#solidity #web3 #update #ether #اتریوم

در استاندارد جدید ۲۳ گزینهٔ std::expected معرفی شده ‌است که اجازه می‌دهد خطاها را بهتر مدیریت کنیم.

مدیریت خطا در سی‌پلاس‌پلاس به وسیلهٔ بیانیه‌های try، catch و throw انجام می‌شود. این ویژگی به برنامه‌نویس این امکان را می‌دهد که خطاها را شناسایی کرده و به دسته‌بندی کرده و سپس به شکل مناسبی برخورد کند.
همچنین کلاس‌هایی مانند std::exception یک کلاس پایه در سی‌پلاس‌پلاس است که برای نمایش استثناء‌ها (خطاها) در هنگام اجرای برنامه استفاده می‌شود. این کلاس یک رابط عمومی به نام what دارد که متنی که توضیح خطا را حاوی می‌شود، به عنوان یک رشته C-style (const char*) باز می‌گرداند.

۱) این نوع داده به شما این امکان را می‌دهد که یک عدد بازگشتی معمولی (نتیجه موفقیت‌آمیز) یا یک کد خطا (نتیجه ناموفق) را با هم در یک متغیر ذخیره کنید.
۲) برای برنامه نویسانی که از این نوع داده استفاده می‌کنند، کد برنامه خواناتر و قابل‌فهم‌تر است.
۳) استفاده از std::expected معمولاً در جاهایی مناسب است که خطاها قابل پیش‌بینی و مدیریت شوند.

import <print>;
import <expected>;
 
enum class ErrorType { InvalidName, NotFound, OtherError };
 
auto getName(std::string name) -> std::expected<std::string, ErrorType>
{
    if (name != "Kambiz") {
        return std::unexpected(ErrorType::InvalidName);
    }
    return name;
}
 
auto main() -> int {
 
    auto result = getName("Compez");
 
    if (result.has_value()) {
        std::println("Result: {}", result.value());
    } else {
        ErrorType error = result.error();
        switch (error) {
        case ErrorType::InvalidName:
            std::println("Error: Invalid Name!");
            break;
        case ErrorType::NotFound:
            std::println("Error: Not Found!");
            break;
        case ErrorType::OtherError:
            std::println("Error: Other Error!");
            break;
        }
    }
 
    return 0;
}

در اینجا، یک تابع به نام getName تعریف شده است که یک نام به عنوان ورودی دریافت می‌کند و یک std::expected را باز می‌گرداند. اگر نام "Kambiz" نباشد، یک std::unexpected با ErrorType::InvalidName ایجاد می‌شود و اگر نام معتبر باشد، خود نام به عنوان مقدار بازگشتی استفاده می‌شود.

سپس در تابع main، ما از تابع getName برای دریافت نتیجه استفاده می‌کنیم. اگر نتیجه دارای مقدار باشد (با فراخوانی()has_value)، آن مقدار با استفاده از ()value چاپ می‌شود. اگر نتیجه دارای خطا باشد، ما با استفاده از ()error نوع خطا را دریافت کرده و با استفاده از یک switch به تصمیمات مرتبط با نوع خطا می‌رسیم و پیام مناسب چاپ می‌شود. توجه داشته باشید که در دسترسی به()error، ممکن است بعضی از پیاده‌سازی‌های expected به جای ()error از ()value برای دسترسی به خطا استفاده کنند.

به نظر می‌رسد این ویژگی می‌تواند به صورت چشم‌گیری روش مدیریت خطاها را بهبود سازد.

#cpp20 #cpp23 #expected #چالش #سی‌روزه #رمضان #روز_بیست_و_چهارم

بخش تخصصی دوم (به‌روز رسانی Solidity) |تابع بازگشتی (Fallback)

تابع Fallback یک قابلیت مهم در قراردادهای هوشمند سالیدیتی است. هر قرارداد می‌تواند حداکثر یک تابع Fallback داشته باشد. این تابع با استفاده از کلیدواژه‌های ()fallback یا fallback(bytes calldata input) external [payable] تعریف می‌شود (هر دو بدون کلیدواژه function). این تابع باید دارای سطح دسترسی external باشد.

تابع Fallback در دو حالت اجرا می‌شود:
۱) عدم تطابق با سایر توابع: هنگامی که فراخوانی به قرارداد ارسال می‌شود اما هیچ یک از توابع دیگر با امضای تابع فراخوانی مطابقت ندارند، تابع Fallback اجرا می‌شود.
۲) عدم وجود داده: اگر اصلاً داده‌ای با تراکنش ارسال نشود و هیچ تابع receive Ether وجود نداشته باشد، تابع Fallback اجرا می‌شود.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.2 <0.9.0;

contract Test {
    uint x;
    // This function is called for all messages sent to
    // this contract (there is no other function).
    // Sending Ether to this contract will cause an exception,
    // because the fallback function does not have the `payable`
    // modifier.
    fallback() external { x = 1; }
}

contract TestPayable {
    uint x;
    uint y;
    // This function is called for all messages sent to
    // this contract, except plain Ether transfers
    // (there is no other function except the receive function).
    // Any call with non-empty calldata to this contract will execute
    // the fallback function (even if Ether is sent along with the call).
    fallback() external payable { x = 1; y = msg.value; }

    // This function is called for plain Ether transfers, i.e.
    // for every call with empty calldata.
    receive() external payable { x = 2; y = msg.value; }
}

contract Caller {
    function callTest(Test test) public returns (bool) {
        (bool success,) = address(test).call(abi.encodeWithSignature("nonExistingFunction()"));
        require(success);
        // results in test.x becoming == 1.

        // address(test) will not allow to call ``send`` directly, since ``test`` has no payable
        // fallback function.
        // It has to be converted to the ``address payable`` type to even allow calling ``send`` on it.
        address payable testPayable = payable(address(test));

        // If someone sends Ether to that contract,
        // the transfer will fail, i.e. this returns false here.
        return testPayable.send(2 ether);
    }

    function callTestPayable(TestPayable test) public returns (bool) {
        (bool success,) = address(test).call(abi.encodeWithSignature("nonExistingFunction()"));
        require(success);
        // results in test.x becoming == 1 and test.y becoming 0.
        (success,) = address(test).call{value: 1}(abi.encodeWithSignature("nonExistingFunction()"));
        require(success);
        // results in test.x becoming == 1 and test.y becoming 1.

        // If someone sends Ether to that contract, the receive function in TestPayable will be called.
        // Since that function writes to storage, it takes more gas than is available with a
        // simple ``send`` or ``transfer``. Because of that, we have to use a low-level call.
        (success,) = address(test).call{value: 2 ether}("");
        require(success);
        // results in test.x becoming == 2 and test.y becoming 2 ether.

        return true;
    }
}

- یک تابع Fallback همیشه داده دریافت می‌کند، اما برای دریافت اتر (ETH) باید با payable علامت‌گذاری شود.
- در صورت استفاده از نسخه با پارامترها، input حاوی تمام داده‌های ارسال شده به قرارداد (معادل msg.data) خواهد بود و می‌تواند داده‌ای را در output برگرداند. داده برگشتی به صورت ABI رمزگذاری نخواهد شد.
- در بدترین حالت، اگر از یک تابع Fallback با قابلیت دریافت اتر (payable) به جای تابع receive استفاده شود، تنها می‌تواند روی ۲۳۰۰ واحد Gas تکیه کند.
- همانند هر تابع دیگری، تابع Fallback می‌تواند عملیات پیچیده‌ای را انجام دهد، به شرطی که Gas کافی برای آن تامین شود.

#solidity #web3 #update #ether #اتریوم

توی این مملکت به هیچ یک از تجاوز‌هایی که به مال و جان و زندگی و معیشت و در کل حق مردم میشه، واکنشی نمیدن! لام تا کام، کور و کر و لال هستن؛ اما نصف شب به زبان عِبری واکنش نشون میدن به اون سر مرز‌ها برای محو متجاوزین!!!

در همین حد همه چیز شفاف هست! 😉

سوأل این‌که کدوم زبان رو برای وب ۳ یاد بگیرم؟! قبلاً هم گفتم برای بک‌اند و زیر ساخت‌ها زبان‌های زیر:

- قطعاً ++C و Rust و Go

۱) بین این‌ها ++C از همشون مطمئن‌تر و خفن‌تره! مثال واقعی؟ پادشاه‌ ارز‌های دیجیتال سلطان بزرگ بیت‌کوین!
۲) خروجی واقعی از Go مثال بزنم؟ ملکهٔ ارز‌ها، اتریوم!
۳) در مورد راست مثال بزنم؟ شبکهٔ لایه L2 از اتریوم و زیرساخت‌های NFT!

برای لایه‌های بالاتر زبان‌های زیر:

- JavaScript/TypeScript

برای قرارداد‌نویسی بر روی بستر EVM:

- زبان برنامه‌نویسی سالیدیتی Solidity

زبان‌های دیگه هم کاربرد دارند، قبلاً هم گفتم SDK برای همشون وجود داره. اما پر کاربرد‌ترینشون همین‌ها هستن اما رابط‌های رسمی براشون وجود نداره مگر اینکه بشینی از صفر خودت یه چیزی سر هم کنی که بتونی یک نسخه از محصول dApp رو باهاش سازگار کنی.

پیشنهاد من چیه؟ حتی اگه هیچی نتونی یاد بگیری، JavaScript رو باید تو جعبه ابزارت داشته باشی! در غیر این صورت فرصت‌های زیادی رو در دنیای وب ۳ از دست خواهی داد.

یادگیری HTML/CSS هم که دیگه یادت نره این‌ها رو باید عین آب خوردن بلد باشی که الآن هرکسی سواد اینترنت داشته باشه اینارو بلده. 😐

با هر کدوم از ابزار‌ها بتونی بالاترین راندمان رو نشون بدی، اون ابزار مناسب هست.
اما در مورد سی++ قضیه خیلی متفاوته، چون کاربردش چند-منظوره هست. در همهٔ شاخه‌های مختلف می‌تونی ازش استفاده کنی؛ سخته! اما خب یک زبان کاملاً تخصصی و خفنه.

این گزینهٔ Purge Followers دنبال کننده‌هایی رو نشون میده که اسپم نیستند. یعنی کاربران فیلتر شده رو شمارش می‌کنه.

کاربرانی که غیر فعال نباشن، اسپمر نباشن و به هر نحوی رتبه‌های خوب و حساب با کیفیتی داشته باشن.