Daniel Hilst dhilst

A simple boolean language with definitions implemented over Sexp.t

Conclusions:

Is pretty easy to write a custom sexp_of_t and t_of_sexp functions.
This lets us to add some sugar over the atoms, I use ?v for variables as an example here
On top of that we can build superset of S-Expressions language which is easy to parse and very expressive

!!!! from manual !!!!

@TODO: FIX THIS!

	#include <iostream>
	#include <memory>

	namespace foo {

	// Here is how to create read only objects in C++23


	// Step 1, define a class
	class foo {

	// Phantom is a phatom type. It means that it is not used
	// during runtime, but play type safety roles during compile
	// time.
	template <typename Phantom>
	struct StrongId {
	int id;

	// Conversion int -> StrongId<T> must to be explicit
	explicit StrongId(auto id_) : id(id_) {}

	#![feature(try_blocks, try_trait_v2)]
	#![allow(dead_code)]

	#[derive(Debug)]
	struct Foo<T>(T);

	// Parametric types are bound during method calls
	trait Bar<T> {
	// Associated types are bound during Trait implementation
	type AT;

	from lark import Lark, Transformer, v_args

	# 1. Define the grammar for second order logic using ASCII characters
	grammar = """
	start: formula

	?expr: arith_expr
	\| bool_expr

	?arith_expr: term

	<html>
	<head>
	<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">
	<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js" integrity="sha384-kenU1KFdBIe4zVF0s0G1M5b4hcpxyD9F7jL+jjXkk+Q2h455rYXK/7HAuoJl+0I4" crossorigin="anonymous"></script>
	</head>
	<body>
	<script>
	function html(text, ...values) {
	const html = text.flatMap((text, i) => {
	return [text, values[i]?.outerHTML \|\| values[i]]

	from typing import ParamSpec, TypeVar, Callable, reveal_type


	T = TypeVar("T")
	P = ParamSpec("P")


	def tco(f: Callable[P, T]) -> Callable[P, T]:
	unwind = False

	from typing import *
	from typing_extensions import ParamSpec

	A = TypeVar("A")
	B = TypeVar("B")
	C = TypeVar("C")
	D = TypeVar("D")
	E = TypeVar("E")
	F = TypeVar("F")
	G = TypeVar("G")

	open Format

	type term =
	\| Var of int
	\| Lamb of term
	\| App of term * term

	let rec shift i depth = function
	\| Var x when x < depth -> Var x
	\| Var x -> Var (x + i)