cblp

-- stack --resolver=lts-23.20 script

import Test.Tasty
import Test.Tasty.HUnit
import Test.Tasty.QuickCheck as QC
import Test.Tasty.Runners
import Test.Tasty.SmallCheck as SC

empty :: [a]
empty = []

cblp

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

template<class Variant, class... Ts>
auto match(Variant v, Ts... matchers) {
    return visit(overloaded{matchers...}, v);
}

struct Human {string name; int age;};
struct Animal {string kind; int age;};

cblp

#!/usr/bin/env python3

import operator
from typing import Callable, NamedTuple, Optional, TypeVar, Generic


A = TypeVar('A')


class Lazy(Generic[A]):

cblp

#include <iostream>
using namespace std;

#define LAZY(expression) Lazy<Cons>{[=]{ return expression.get(); }}
#define LAZY_REF(expression) Lazy<Cons>{[&]{ return expression.get(); }}

template<typename T>
class Lazy {
    private:
        mutable shared_ptr<T> value;

cblp

#include <iostream>
#include <complex>
using namespace std;

#include <numbers>
using namespace std::numbers;

struct Expr {
    virtual string source() const = 0;
    virtual shared_ptr<Expr> derive() const = 0;

cblp

{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE LambdaCase     #-}

data Expr
    = Lit Integer
    | Var
    | Add Expr Expr
    | Mul Expr Expr
    | Pow Expr Expr
    | Sin Expr

cblp

{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE LambdaCase     #-}

import Control.Monad.State

data Action
  = For Expr (Expr -> Action)
  | Print Expr

data Expr

cblp

{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

-- | This module contains usage example of suggested `MonadParsecDbg` type class,
-- minimized, but, I hope, demonstrative
--
-- If someone have better solution, I would like to see it
module Main where

cblp

{-# LANGUAGE MonadComprehensions #-}
{-# LANGUAGE OverloadedLists     #-}
{-# LANGUAGE RebindableSyntax    #-}

import           Data.Set (Set, singleton)
import           GHC.Exts
import           Prelude

xs :: Set Int
xs = [3, 15]

cblp

{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE LambdaCase        #-}
{-# LANGUAGE TemplateHaskell   #-}
{-# LANGUAGE TypeFamilies      #-}

module Mystudies where

import           Data.Foldable            (toList)
import           Data.Functor.Foldable    (fold)