sjkillen

1. Problem Mapping

• Think about how to express problem as numbers with constraints
• Write code to map into domain and map from domain

2. Rely on the constraint solver

• Avoid using is/2 entirely
• Implictly using =/2 through predicate calls
• Use #= instead of is/2 and =/2
• Verify that solver was used by printing variables before calling label - if the variables all have concrete values, then you are not relying on the solver

sjkillen

struct Base<Extension = ()> {
    ext: Extension,
    x: i32,
    y: i32,
    z: i32,
}

trait BaseAbstractMethods {
    fn combine_components(&self, a: i32, b: i32) -> i32;
}

sjkillen

import bpy
from bpy.props import IntProperty, FloatProperty
from bpy.types import Armature, PoseBone, KinematicConstraint, Object


def ik_constraints(armature: Object):
    assert type(armature.data) is Armature
    return (constraint for pbone in armature.pose.bones
                       for constraint in pbone.constraints
                       if type(constraint is KinematicConstraint))

sjkillen

from bpy.types import Mesh

def sort_uv_layers(mesh: Mesh):
    # UV layers use non-pythonic reference semantics, safest to always reference by their indices
    assert len(mesh.uv_layers) <= 7, "There must be fewer than 8 UV maps to sort (one less than the Blender maximum of 8)"
    initial_layers = [[i, layer.name] for i, layer in enumerate(mesh.uv_layers)]
    initial_layers.sort(key=itemgetter(1))
    for i, layer_name in tuple(initial_layers):
        assert mesh.uv_layers[i].name == layer_name, mesh.uv_layers[i].name + " " + layer_name        
        mesh.uv_layers.active = mesh.uv_layers[i]

sjkillen

def factorial(n, accumulator=1):
    if n == 1:
        return accumulator
    return factorial(n - 1, accumulator * n)


try:
    factorial(1000)
except RecursionError:
    print("TOO MUCH RECURSION!")

sjkillen

from functools import singledispatch, wraps
from collections.abc import Iterable

def one_or_many(fn):
    @wraps(fn)
    @singledispatch
    def wrapper(*args, **kwargs):
        fn(*args, **kwargs)
    
    @wrapper.register

sjkillen

import bpy
from bpy.types import Scene, Armature, Mesh
from operator import itemgetter
from itertools import chain


def create_geometry(armature: Armature) -> Mesh:
    roots = tuple(bone for bone in armature.bones if bone.parent is None)
    
    mesh = bpy.data.meshes.new(armature.name)

sjkillen

S='sleep 1; echo hello world; echo "$S" >> quine.bash; sleep 1'
sleep 1
echo hello world
echo "$S" >> quine.bash
sleep 1

sjkillen

use std::iter::once;

#[derive(Debug)]
pub enum IterNum<T, I: Iterator<Item = T>> {
    Zero,
    One(T),
    More(I),
}

pub fn inum<T, I: Iterator<Item = T>>(mut items: I) -> IterNum<T, impl Iterator<Item = T>> {

sjkillen

mod util;
use std::ops::Range;
use util::*;

fn main() {
    let v: Vec<Range<i32>> = [(1..4), (11..14), (111..114)]
        .into_iter()
        .map(|r| r.clone())
        .collect();
    for items in v.into_iter().flat_cprod() {