sampersand

[12:27:12 PM 1029] ruby % git diff
diff --git a/gc.c b/gc.c
index 3fd2a3b33f..f909e5b81b 100644
--- a/gc.c
+++ b/gc.c
@@ -11460,6 +11460,10 @@ gc_stress_get(rb_execution_context_t *ec, VALUE self)
 static void
 gc_stress_set(rb_objspace_t *objspace, VALUE flag)
 {
+    if (flag != Qtrue && flag != Qfalse) {

sampersand

CWD =: (<./CWD i:'/\') {.CWD=: ;(4!:3''){~4!:4 CWD=: <'CWD'
raw =: }: freads CWD , '/day2.txt'
die =: {{ echo y throw. }}

NB. raw =: '1,9,10,3,2,3,11,0,99,30,40,50'
ints =: ". every (',' cut raw)
ints =: (12 2) (1 2) } ints

number_of_params =: ((_ 3 3) , (_ * i.96) , 0) & {

sampersand

raw =: '1,9,10,3,2,3,11,0,99,30,40,50'
ints =: ". every (',' cut raw)

run_one =: {{
	'op src1 src2 dst' =. (x + i.4) { y

	select. op
	case. 1 do. ((src1{y)+(src2{y)) dst } y
	case. 2 do. y((src1{y)*(src2{y)) dst } y

sampersand

#!/usr/bin/env ruby

# Knight in ruby, but with copious amounts of monkey patching :-)

class Fn
  @fns = {}

  def self.register(name, ...) = @fns[name] = Fn.new(...)
  def self.lookup(name) = @fns.fetch(name)
  def initialize(call_args: true, &block) @call_args, @block = call_args, block end

sampersand

class ParseError < RuntimeError; end

class Token
  attr_reader :value, :kind, :location

  def initialize(value, kind, location)
    @value = value
    @kind = kind
    @location = location
  end

sampersand

class Literal {
	constructor(value) { this.value = value; }
	run(env) { return this; }
	toInteger() { return parseInt(this.value); }
	toString() { return "" + this.value; }
	toBoolean() { return !!this.value; }
}

class Variable {
	constructor(name) { this.name = name; }

sampersand

#!ruby -W0anF(?=) -rstringio

# Prompt: Create a program that can check to see if an input
# (given any way you want) contains all the letters in the
# alphabet, case-insensitive. Note that the input string will
# only be ascii, but it may contain non-alphabetic letters.
# Make it cursed.
END{p$====032}
BEGIN{$_=$0.tr *%w*A-Z a-z*; sub $&,%  while/\W|\d|_/; $stdin=StringIO.new$_}

sampersand

#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <assert.h>

static inline void LIST_NOFREE(void *t) {}
#define LIST_DEFINE(kind, list_name, free_fn)                                  \
typedef struct list_name {                                                     \
	size_t len, cap;                                                           \
	kind *eles;                                                                \

sampersand

grammar Syntax {
	rule TOP { <expr> .* }
	rule expr { <.ws> [<literal> | <function>] }
	token ws { [ <[(){}[\]:\s\n]> | '#' \N* \n? ]* }

	proto token literal {*}
	token literal:sym<identifier> { <[a..z_]> <[a..z0..9_]>* }
	token literal:sym<number> { \d+ }

sampersand

module FP
	class MultiMethod
		NoMethodMatchesError = Class.new StandardError

		def initialize = @methods = []

		def add(callable, conditions) = @methods.push([callable, conditions])

		def call(...)
			@methods.each do |callable, conditions|