bluenote10

trait CrossProduct[A,B,C] {
  def cross( as: Traversable[A], bs: Traversable[B] ): Traversable[C]
}

trait LowPriorityCrossProductImplicits {
  private type TV[X] = Traversable[X]

  implicit def crosser2[A,B] = new CrossProduct[A,B,(A,B)] {
    def cross( as: TV[A], bs: TV[B] ): TV[(A,B)] = for { a <- as; b <- bs } yield (a, b)
  }

bluenote10

import os, threadpool

proc spawnBackgroundJob[T](f: iterator (): int): TChannel[T] =

  type Args = tuple[iter: iterator (): T, channel: ptr TChannel[T]]
  #type Args = tuple
  #  iter: iterator (): T
  #  channel: ptr TChannel[T]

  proc threadFunc(args: Args) {.thread.} =

bluenote10

type
  Test = object
    field: seq[int] not nil

var t: Test
echo t.field.isNil() # true

bluenote10

#!/usr/bin/env sh

# A wrapper around the Nim compiler to allow for easy scripting of Nim. Puts
# all temporary files in a temporary directory and cleans up after itself.
#
# Usage:
#  - add `#!/usr/bin/env nimrun` at the beginning of your script
#  - execute the nim file with it, for example, `nimrun file.nim args`
#
# Possible future extentions:

bluenote10

macro stringParseTest(s: string): stmt =
  let trueString = s.strVal
  let ne = parseExpr(trueString)
  let ns = parseStmt(trueString)
  echo treeRepr(ne)
  echo treeRepr(ns)
  # looking good:
  # Infix
  #   Ident !"+"
  #   Ident !"y"

bluenote10

import os, threadpool

proc spawnBackgroundJob[T](channel: ptr Channel[T], f: iterator (): T) =
  
  type Args = tuple[iter: iterator (): T, channel: ptr Channel[T]]
  
  proc threadFunc(args: Args) {.thread.} =
    echo "Thread is starting"
    let iter = args.iter
    var channel = args.channel # note: still a `ptr Channel`

bluenote10

value
100
150
200

bluenote10

import future
import options

#[
proc flatMap[X](iter: iterator(): X, mapper: X -> iterator(): X): (iterator(): B) =
  result = proc() =
    yield X


proc iter(): int =

bluenote10

// https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=8921bcc0302b066ef5e39bc6e9a8b7e3

#![allow(dead_code)]

use std::collections::HashMap;

struct Test {
    offset: f64,
    buffers: HashMap<i32, Vec<f64>>,
    data: Vec<f64>,

bluenote10

import numpy as np
import matplotlib.pyplot as plt

from ssqueezepy import ssq_cwt, cwt


SAMPLE_RATE = 44100


def sine(freq, num_samples=SAMPLE_RATE // 4, amp=1.0):