Techcable

# Website: https://attractivechaos.github.io/klib/
# Source: https://github.com/attractivechaos/klib
#
# Meson Wrap Gist:
# Meson Wrap Version: 1

[wrap-git]
url = https://github.com/attractivechaos/klib.git
revision = head
patch_directory = klib

Techcable

(import sh)
(import spork)

(def- metric-prefixes ["K" "M" "G" "T" "P" "E"])

(defn- makeunit [&named name base-prefix binary]
  (default binary false)
  (assert (keyword? name))
  (assert (not (empty? (string name))))
  (assert (string? base-prefix))

Techcable

const std = @import("std");

fn sdk_root() []const u8 {
    return std.fs.path.dirname(@src().file) orelse ".";
}

fn dep_root_working() []const u8 {
    const sdk_root_val = comptime blk: { break :blk sdk_root(); };
    return sdk_root_val ++ "/deps/mpack";
}

Techcable

#!/bin/bash

# Available as github gist: https://gist.github.com/Techcable/b83df781602857dd2f6cf0074e50ba77

set -e

if [[ $# -eq 1 ]]; then
    OUT_FILE="$(realpath "$1")";
else
    echo "ERROR: Invalid arguments" >&2;

Techcable

# See also andrewchambers/janet-sh for a more complete (and awesome) solution:
# https://acha.ninja/blog/dsl_for_shell_scripting/
#
# Source: https://github.com/janet-lang/jpm/blob/07b0c18daf75cfdf098eff5526a17ad0436e3dc0/jpm/shutil.janet#L123-L137
(defn exec-slurp
  "Read stdout of subprocess and return it trimmed in a string."
  [& args]
  (when (dyn :verbose)
    (flush)
    (print ;(interpose " " args)))

Techcable

(defn primes-before
  "Gives all the primes < limit"
  [limit]
  (assert (int? limit))
  # Janet has a buffer type (mutable string) which has easy methods for use as bitset
  (def buf-size (math/ceil (/ (+ 1 limit) 8)))
  (def is-prime (buffer/new-filled buf-size (bnot 0)))
  (buffer/bit-clear is-prime 0)
  (buffer/bit-clear is-prime 1)
  (for n 0 (math/ceil (math/sqrt limit))

Techcable

# Ported from this Python code: https://gist.github.com/Techcable/c411b3a550e252b1fd681e1fc1734174		
#		
# Based on R. Sedgewick's Algorithms, Chapter 2.4 

(defn swap [l a b]
  (let [aval (get l a) bval (get l b)]
    (put l a bval)
    (put l b aval)))

(defn heap-sort [l] 

Techcable

import operator


def swap(l: list, i: int, j: int):
    assert i < len(l), i
    assert j < len(l), j
    l[i], l[j] = l[j], l[i]


def heap_sort(l: list) -> list:

Techcable

from math import floor, log10
import sys

WORDS = {
  0: 'zero',
  1: 'one',
  2: 'two',
  3: 'three',
  4: 'four',
  5: 'five',

Techcable

from __future__ import print_function
from sys import getsizeof, stderr
from itertools import chain
from collections import deque
try:
    from reprlib import repr
except ImportError:
    pass

def total_size(o, handlers={}, verbose=False):