jemand2001

package sprachen.notfinal;

public abstract class Base {
    @PseudoFinal
    void f() {
        System.out.println("base class");
    }
}

jemand2001

namespace range {
    class range {
        int start = 0;
        int step = 1;
        int stop;
        struct range_iterator {
          int current;
          bool operator != (range_iterator b) const {
            return (start != b.start && stop != b.stop && step != b.step) || current < b.current;
          }

jemand2001

#ifndef PROPERTY_PROPERTY_HPP
#define PROPERTY_PROPERTY_HPP
#include <functional>

template <typename T>
struct Property {
    using setter_type = std::function<void(Property<T>&, T)>;
    using getter_type = std::function<T *(Property<T>&)>;
    typedef T element_type;
    typedef T *pointer_type;

jemand2001

try:
    import numpy
except ImportError:
    # pypy
    pass

to_run = []
def run(f):
    fx = lambda: f(100_000)
    fx.__name__ = f.__name__

jemand2001

module ConditionalList where

-- largely curtesy of citrusMarmelade
import Control.Monad
import Data.Monoid

if_ :: Applicative f => f () -> Bool -> f ()
if_ = flip when

type Append a = Endo [a]

jemand2001

#include <iostream>
#include <memory>
#include <ranges>
#include <source_location>
#include <vector>

#include "traits.hpp"

class Scene;
class Entity;

jemand2001

#include <variant>
#include <functional>
#include <iostream>

template <typename Info, typename Actual>
class Lazy {
    struct info_holder {
        Info x;
    };

jemand2001

#include <dlfcn.h>
#include <format>
#include <memory>
#include <stdexcept>
#include <unordered_map>

struct dl_exception : std::runtime_error {
    using std::runtime_error::runtime_error;
};

jemand2001

#include <format>
#include <iostream>
#include <source_location>
#include <string_view>
#include <tuple>
#include <unordered_map>

enum class LogLevel { DEBUG, INFO, WARNING, ERROR, CRITICAL };

namespace CLIColors {

jemand2001

#include <coroutine>
#include <expected>
#include <optional>
#include <iostream>

#include "return_object_holder.hpp"

using std::coroutine_traits;

template <typename R, typename E>