daltonclaybrook

import Combine

struct AwaitPublisher<Value>: Publisher {
	typealias Output = Value
	typealias Failure = Never

	private let block: () async -> Value

	init(block: @escaping () async -> Value) {
		self.block = block

daltonclaybrook

//
//  linked_list.c
//  CLox
//
//  Created by Dalton Claybrook on 8/13/21.
//

#include <stdlib.h>
#include <string.h>
#include "linked_list.h"

daltonclaybrook

import Foundation
import libspacekit

public struct AstroPhoto: Equatable {
    public let title: String
    public let url: URL
}

private struct AstroPhotoContext {
    let fetcher: AstroPhotoFetcher

daltonclaybrook

import Foundation

private enum TimeoutResult<T> {
    case success(T)
    case timeout
}

struct TimeoutError: Error {}

/// Run an arbitrary async task that is cancelled after a provided timeout interval

daltonclaybrook

ACTION="build"
AD_HOC_CODE_SIGNING_ALLOWED="YES"
ALTERNATE_GROUP="staff"
ALTERNATE_MODE="u+w,go-w,a+rX"
ALTERNATE_OWNER="dalton.claybrook"
ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES="NO"
ALWAYS_SEARCH_USER_PATHS="NO"
ALWAYS_USE_SEPARATE_HEADERMAPS="NO"
APPLE_INTERNAL_DEVELOPER_DIR="/AppleInternal/Developer"
APPLE_INTERNAL_DIR="/AppleInternal"

daltonclaybrook

#[macro_use]
extern crate lazy_static;
use regex::{Captures, Regex};
use std::fs;
use std::ops::Range;
use std::str::FromStr;

#[derive(Debug)]
enum AdventError {
    Unknown,

daltonclaybrook

import RxSwift

/// This type is similar to `BehaviorRelay`, but it allows for mutating an element in-place
/// rather than assigning a new one.
///
/// This is useful for large copy-on-write containers. For example, it's less expensive to append
/// an element to an `Array` with 1M entries than it is to make a new `Array` by concatenating it with
/// a second `Array` with one element.
public final class MutableRelay<Element>: ObservableType {
	public private(set) var value: Element

daltonclaybrook

/// Types that implement this trait provide the rules
/// for replacing objects of the same type.
pub trait Replaceable {
    type Key: Eq;
    fn unique_key(&self) -> Self::Key;
    fn should_replace(&self, other: &Self) -> bool;
}

/// Trait implemented for collections that can be
/// filtered using replacement rules

daltonclaybrook

private func fibonacci(_ n: Int) -> Int {
  guard n != 0, n != 1 else { return n }
  return fibonacci(n - 1) + fibonacci(n - 2)
}

daltonclaybrook

pico-8 cartridge // http://www.pico-8.com
version 18
__lua__
-- this is called automatically
-- one time when the game starts
-- but we'll call it again later
-- to start the game over
function _init()
	-- later, when the game is over
	-- we'll call this functiom