frenchy64

Occurrence Typing is Compositional

A few months ago, Sam Tobin-Hochstadt explained to me how occurrence typing is compositional. While I had taken this for granted previously, comparing occurrence typing to other systems makes it clear that this is an important property to have.

First of all, what is occurrence typing? In dynamically typed programs, there are often type invariants enforced at program branches.

(fn [a :- (U nil String)]
  (if a
 (count a)

frenchy64

(This is a really long answer to feedback on plumatic/schema#445)

Sorry, I don't understand from here down.

My bad, there's a ton of implicit decisions and I'm only explaining the tiny details :) I'll try writing this again.

Are you basing this design off an existing language or library that I can read about to get a better understanding?

This is a combination of several ideas and tradeoffs.

frenchy64

https://github.com/cgrand/macrovich/commit/9f5bd6f2777f0494e46ce7c430fd1fcef2690475#r67189464

@viebel Without this, you need to write macros like this:

(defmacro my-macro []
  `(macros/case
     :clj 1
     :cljs 2))

frenchy64

(ns clojure.core.typed.test.trampoline
  (:require [clojure.core.typed :as t]))

(declare funb)

(t/ann-many [Number -> (Rec [f]
                         (U Number [-> (U Number f)]))]
            funa funb)
(defn funa [n]
  (if (= n 0)

frenchy64

typed.clj.refactor=> (refactor-form-string "+" {})
"clojure.core/+"
typed.clj.refactor=> (refactor-form-string "(defn foo [a] (+ a 3))" {})
"(clojure.core/defn foo [a__#0] (clojure.core/+ a__#0 3))"
typed.clj.refactor=> (refactor-form-string "(defmacro foo [a] `(+ ~a 3))" {})
"(clojure.core/defmacro foo [a__#0] `(+ ~a__#0 3))"

frenchy64

The Hidden Data Flow in Types

On the surface, function types simply describe inputs and outputs—indeed, that's how they're used in most type systems. But there's more to function types!

Fascinatingly, a function type can be transformed into a data flow graph that predicts the inner workings of any function that has that type. Using this graph, intricate dependencies between function inputs and outputs can be inferred

frenchy64

RFC: Animation for cljfx

This is an initial attempt at supporting animations in cljfx. Running instructions are below.

The actual animation logic is here under the Demo comment.

The original code is here.

Running

frenchy64

Why Objects were successful

https://www.cs.cmu.edu/~charlie/courses/15-214/2014-fall/slides/25-history-oo.pdf

• essense of objects is (dynamic) dispatch
• dispatch provides interoperability
• first-class interoperability is critical to frameworks and ecosystems
• frameworks and ecosystems are economically critical to the software industry
• likely a significant factor in objects' success
• Also talks about early mistakes in Simula

Why objects are inevitable

frenchy64

#Sample code

#Hello world

"Hello world!" print

#Factorial

factorial := method(n, if(n == 1, 1, n * factorial(n - 1)))
99 bottles of beer

frenchy64

(ns colored-lti-clj.core)

(defalias List
  (TFn [a]
    '{:match (All [b] [(ListVisitor a b) :-> b])}))

(defalias ListVisitor
  (TFn [a b]
    '{:caseNil (All [:-> b])
      :caseCons (All [a (List a) :-> b])}))