leontrolski

import os
from typing import TypeVar
import pydantic

T = TypeVar("T")


class _Missing:
    ...

leontrolski

<style>
.red {
    color: red;
}
</style>

<div id="root"></div>

<script>

leontrolski

# 105 line parser and interpreter for a small language with
# integers, assignments, lexical scope, first class functions
from __future__ import annotations
from dataclasses import dataclass, replace
from typing import Callable, Union

source = """
(#{
    (#= x 5)
    (#= f

leontrolski

import base64
from functools import lru_cache
import logging
from time import sleep, time
from typing import Dict, TypedDict, Tuple, List, TypeVar

import requests
from google.auth.transport.requests import AuthorizedSession
import google.auth

leontrolski

# pip install sqlalchemy testing.postgresql
# see also: https://blog.crunchydata.com/blog/message-queuing-using-native-postgresql
import threading
from contextlib import contextmanager

from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import  sessionmaker
import testing.postgresql

leontrolski

# This is a version of https://gist.github.com/natekupp/1763661 without
# using mutation and with some other simplifications. Hopefully it's slightly
# easier to follow. Performance wise - from some small benchmarking - it has
# the same O(N) characteristics/memory usage, but is about twice as slow.
#
# Use it like:
#
#    b = Node([], [])
#    b = add(b, n)
#    print(pp(b))

leontrolski

//   ___________________________
// _| generic constraint solver |__________________________________________________

type Assignments<V> = {[K: string]: V}
type Constraint<V> = (assignments: Assignments<V>) => boolean
type KProperties<V> = {
    domain: V[]
    constraints: Constraint<V>[]
}
type Problem<V> = {

leontrolski

// 80 line parser and interpreter for a small language with
// integers, assignments, lexical scope, first class functions
const source = `
(block
    (assign x 5)
    (assign f
        (function
            (a b)
            (block
                (assign c (+ a b))

leontrolski

"""This isn't the most efficient, but is the most "natural" to me.

match(i, j) => do letters `s[:i]` match chars `p[:j]`

- If i == -1, return False
- Set letter to the last of letters and char to last of chars
- If chars is empty, the only match is if letters is empty
- If char is *, did s[:i-1] match p[:j] or did s[:i] match p[:j-1]?
- Else does char match letter and did s[:i-1] match p[:j-1]?

leontrolski

from StringIO import StringIO
from itertools import islice, izip_longest, tee

import pandas as pd
from pandas.util.testing import assert_frame_equal

def read_data_frame_str(s, first_col_index=False):
    """Read a markdown-style description of a table into a DataFrame.
    :param str s:
    :param bool first_col_index: if `True`, use the first column as an index.