cgrand

;; cond-> inside -> is fine
(-> input
  (dothis ...)
  (cond-> test (maybe do this also ...))
  (dothat ...))
  
;; cond->> inside ->> isn't fine
(->> input
  (dothis ...)
  (cond->> test (maybe do this also ...)) ; the input seq comes last because of ->> but cond->> expects it first.

jaredly

Thinking about "syntax families", and how to ~categorize them.

My broad thinking is that all syntax can be usefully flattened into "atoms" and "collections" (delimited & separated sequences of atoms and collectiosn), and then a language's syntax can be characterized by "what kinds of atoms are there" and "what kinds of collections are there". The structured editor that I'm building then works at the level of those atoms and collections (the 'reader' phase, in lisp), providing in my opinion a sweet spot of "just enough structure to be powerful & useful with out being overly restrictive & annoying".

Here's how I would describe various syntaxes:

Programming languages

Forth:

jimmyhmiller

https://dynamicland.org/
https://dynamicland.org/#how-the-gallery-works
https://dynamicland.org/#the-scrapbook-is-the-source-of-truth
https://dynamicland.org/2014/CDG_Research_Agenda.pdf
https://dynamicland.org/2014/CDG_Research_Agenda_poster.pdf
https://dynamicland.org/2014/CDG_research_agendas/
https://dynamicland.org/2014/The_Humane_Representation_of_Thought/
https://dynamicland.org/2015/Apparatus_at_Future_Programming_Workshop/
https://dynamicland.org/2015/Apparatus_at_Future_Programming_Workshop/?t=26m21s
https://dynamicland.org/2016/Flowsheets_v1/

ssrihari

An opinionated list of excellent Clojure learning materials

These resources (articles, books, and videos) are useful when you're starting to learn the language, or when you're learning a specific part of the language. This an opinionated list, no doubt. I've compiled this list from writing and teaching Clojure over the last 10 years.

• 🔴 Mandatory (for both beginners and intermediates)
• 🟩 For beginners
• 🟨 For intermediates

Table of contents

1. Getting into the language

jackrusher

// three indices to efficiently support all lookups
function createDB() {
    return {eav: new Map(),
            ave: new Map(),
            vea: new Map()};
}

function addToIndex(xs, x, y, z, triple) {
    let ys = xs.get(x);
    if(ys == undefined) {

lispm

; John McCarthy. Puzzle Solving Program in LISP. Memo 20, Artificial Intelligence Project
; http://www.bitsavers.org/pdf/mit/ai/aim/AIM-020.pdf
; 1960

; Common Lisp translation: Rainer Joswig, 2016, [email protected]
; basically the code is unchanged, but using s-expression syntax in Common Lisp

(defparameter pzl
  '((a1  (a2 a5)              7.5)
    (a2  (a1 a5 a9 a3)        3.5)

mfikes

ClojureScript master now has cljs.core/eval. This delegates to cljs.core/*eval* which, by default throws, but you can bind it to any implementation that can compile and evaluate ClojureScript forms.

If you require the cljs.js namespace (which is the main support namespace for self-hosted ClojureScript), then cljs.core/*eval* is set to an implementation that uses self-hosted ClojureScript for this capability. This means that all self-hosted ClojureScript environments will now have a first-class eval implementation that just works. For example, Planck master:

$ planck -q
cljs.user=> (eval '(+ 2 3))
5

jackrusher

;; knowledge representation, syllogism via knowledge base

(defrecord Triple [subject predicate object])

(def knowledge-base
  [(Triple. :Socrates    :is-a         :Greek)
   (Triple. :Greek       :is-a         :human-being)
   (Triple. :human-being :has-property :mortal)])

(defn collect-predicate-along-axis [kb subject predicate axis]

brandonb927

#!/bin/sh

###
# SOME COMMANDS WILL NOT WORK ON macOS (Sierra or newer)
# For Sierra or newer, see https://github.com/mathiasbynens/dotfiles/blob/master/.macos
###

# Alot of these configs have been taken from the various places
# on the web, most from here
# https://github.com/mathiasbynens/dotfiles/blob/5b3c8418ed42d93af2e647dc9d122f25cc034871/.osx

mattetti

#!/usr/bin/env ruby

require 'json'

file = ARGV.first
raise "Can't find #{file.inspect}" unless File.exist?(file)
header = File.open(file)
doc = {}
properties = {}