You Got Your Idris in My C++

Programmers gripe that we have two kinds of programming languages: the ones we write in for fun, and the ones we write in because we have to. We may enjoy coding that weekend project in Agda, but we have to leave that smile behind on Monday morning when we go back to Java or C++.

But is that really the case? Or can we find a way of bringing the expressiveness, the rigor, or the fun of our favorite languages into our day jobs?

Transcript

1. You got your Idris in my C++! A first look at
 denotational design Ian Dees • @undees Open Source Bridge 2015
4. The problem Fun languages Ruby Clojure Haskell Elixir Work languages C C++ Java
5. Solutions?
6. How do we sneak
 fun languages into work?
7. The green field
8. The toy project
9. By stealth (see JRuby)
10. Another proposal:
11. Denotational Design
12. –Conal Elliott,
 “Denotational design with type class morphisms” “When designing software, in addition to innovating in your implementations, relate them to precise and familiar semantic models.”
13. –Conal Elliott,
 “Denotational design with type class morphisms” “When designing software, in addition to innovating in your implementations, relate them to precise and familiar semantic models.”
14. In other words… 1. Sketch your design in clear notation 2. Implement it in your “day job” language
15. In other words… 1. Sketch your design in (some kind of) clear notation 2. Implement it in your “day job” language
16. What kind of clear notation?
17. Math (or a sufficiently math-y programming language)
18. Meet Idris
19. Haskell’s cousin
20. -- A cousin of Haskell
21. -- A cousin of Haskell twice x = 2 * x
22. -- A cousin of Haskell twice : Int -> Int twice x = 2 * x
23. -- A cousin of Haskell twice : Int -> Int twice x = 2 * x twice 42 —-> 84 : Int
24. Dependently typed
25. Types can be inputs
 to functions
26. -- Types can be inputs to functions isNumeric : Type -> Bool isNumeric Int = True isNumeric String = False
27. -- Types can be inputs to functions isNumeric : Type -> Bool isNumeric Int = True isNumeric String = False isNumeric Int --> True : Bool
28. Types can depend
 on values
29. -- Idris, before we add dependent types data Vec : Type -> Type where Nil : Vec a (::) : a -> Vec a -> Vec a
 

30. -- Idris, before we add dependent types data Vec : Type -> Type where Nil : Vec a (::) : a -> Vec a -> Vec a
 
 False :: True :: (the (Vec Bool) Nil) --> [False,True] : Vec Bool
31. // C++ template <typename T> class vec { public: static vec<T> nil; vec<T> insert(T); };
32. -- Idris data Vec : Nat -> Type -> Type where Nil : Vec Z a (::) : a -> Vec k a -> Vec (S k) a
33. // C++ template <size_t k, typename T> class vec { public: static vec<0, T> nil; vec<k + 1, T> insert(T); };
34. (an aside on numbers)
35. -- Peano numbers Z --> 0 S Z --> 1 ("successor to zero") S (S Z) --> 2 ("successor to successor
 to zero")
37. …is syntactic sugar for…
38. S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S Z))))))))))))))))
 ))))))))))))))))))))))) ))
39. add : Vec n a -> Vec m a -> Vec (n + m) a
40. add : Vec n a -> Vec m a -> Vec (n + m) a add Nil ys = ys add (x :: xs) ys = x :: (add xs ys)
41. You can do math
 on meaning
42. Proofs
43. add : Nat -> Nat -> Nat add Z y = y add (S x) y = S (add x y)
44. How would we check that addition is commutative? (x + y = y + x)
45. Tests?
46. 3 + 2 --> 5 : Integer 2 + 3 --> 5 : Integer
47. –Philip Wadler,
 “Propositions as Types” “For each proof of a given proposition, there is a program of the corresponding type—and vice versa.”
48. Proofs are programs
49. -- Given natural numbers x and y, -- x + y equals y + x
50. -- Given natural numbers x and y, -- x + y equals y + x addCommutes : (x : Nat) -> (y : Nat) -> plus x y = plus y x
51. Proof by induction Base case
 “It’s true for zero” Inductive step
 “If it’s true for x, then it’s true for x + 1”
52. addCommutes Z y = ?base addCommutes (S x) y = let hypothesis = addCommutes x y in ?inductive
53. $ idris math.idr > :m Global metavariables: [Math.inductive,Math.base]
54. > :p base ---------- Goal: ---------- { hole 0 }: (y : Nat) -> y = plus y Z
55. > :p base ---------- Goal: ---------- { hole 0 }: (y : Nat) -> y = plus y Z
56. > intros ---------- Other goals: ---------- { hole 0 } ---------- Assumptions: ---------- y : Nat ---------- Goal: ---------- { hole 1 }: y = plus y Z
57. > intros ---------- Other goals: ---------- { hole 0 } ---------- Assumptions: ---------- y : Nat ---------- Goal: ---------- { hole 1 }: y = plus y Z
58. -- https://github.com/idris-lang/Idris-dev/blob/master/libs/
 -- prelude/Prelude/Nat.idr total plusZeroRightNeutral : (left : Nat) -> left + 0 = left
59. > rewrite (plusZeroRightNeutral y) ---------- Other goals: ---------- { hole 1 } { hole 0 } ---------- Assumptions: ---------- y : Nat ---------- Goal: ---------- { hole 2 }: plus y Z = plus y Z
60. > rewrite (plusZeroRightNeutral y) ---------- Other goals: ---------- { hole 1 } { hole 0 } ---------- Assumptions: ---------- y : Nat ---------- Goal: ---------- { hole 2 }: plus y Z = plus y Z
61. > trivial base: No more goals. > qed Proof completed! Math.base = proof intros rewrite (plusZeroRightNeutral y) trivial
62. And now, for the inductive step
63. > :m Global metavariables: [Math.inductive]
64. > :p inductive ---------- Goal: ---------- { hole 0 }: (x : Nat) -> (y : Nat) -> (plus x y = plus y x) -> S (plus x y) = plus y (S x)
65. > :p inductive ---------- Goal: ---------- { hole 0 }: (x : Nat) -> (y : Nat) -> (plus x y = plus y x) -> S (plus x y) = plus y (S x)
66. > intros ---------- Other goals: ---------- { hole 2 } { hole 1 } { hole 0 } ---------- Assumptions: ---------- x : Nat y : Nat hypothesis : plus x y = plus y x ---------- Goal: ---------- { hole 3 }: S (plus x y) = plus y (S x)
67. > intros ---------- Other goals: ---------- { hole 2 } { hole 1 } { hole 0 } ---------- Assumptions: ---------- x : Nat y : Nat hypothesis : plus x y = plus y x ---------- Goal: ---------- { hole 3 }: S (plus x y) = plus y (S x)
68. -- https://github.com/idris-lang/Idris-dev/blob/master/libs/
 -- prelude/Prelude/Nat.idr total plusSuccRightSucc :
 (left : Nat) ->
 (right : Nat) ->
 S (left + right) = left + (S right)
69. > rewrite (plusSuccRightSucc y x) ---------- Other goals: ---------- { hole 3 } { hole 2 } { hole 1 } { hole 0 } ---------- Assumptions: ---------- x : Nat y : Nat hypothesis : plus x y = plus y x ---------- Goal: ---------- { hole 4 }: S (plus x y) = S (plus y x)
70. > rewrite (plusSuccRightSucc y x) ---------- Other goals: ---------- { hole 3 } { hole 2 } { hole 1 } { hole 0 } ---------- Assumptions: ---------- x : Nat y : Nat hypothesis : plus x y = plus y x ---------- Goal: ---------- { hole 4 }: S (plus x y) = S (plus y x)
71. > rewrite (plusSuccRightSucc y x) ---------- Other goals: ---------- { hole 3 } { hole 2 } { hole 1 } { hole 0 } ---------- Assumptions: ---------- x : Nat y : Nat hypothesis : plus x y = plus y x ---------- Goal: ---------- { hole 4 }: S (plus x y) = S (plus y x)
72. > rewrite hypothesis ---------- Other goals: ---------- { hole 4 } { hole 3 } { hole 2 } { hole 1 } { hole 0 } ---------- Assumptions: ---------- x : Nat y : Nat hypothesis : plus x y = plus y x ---------- Goal: ---------- { hole 5 }: S (plus x y) = S (plus x y)
73. > rewrite hypothesis ---------- Other goals: ---------- { hole 4 } { hole 3 } { hole 2 } { hole 1 } { hole 0 } ---------- Assumptions: ---------- x : Nat y : Nat hypothesis : plus x y = plus y x ---------- Goal: ---------- { hole 5 }: S (plus x y) = S (plus x y)
74. > trivial inductive: No more goals. > qed Proof completed! Math.inductive = proof intros rewrite (plusSuccRightSucc y x) rewrite hypothesis trivial
76. What’s the practical use?
77. Dipping our toes in
78. Denotational design 1. Sketch your design in Idris 2. Implement it in C++
79. Mission:
 Edit audio clips
81. class Audio { public: };
82. class Audio { public: size_t count() const; };
83. class Audio { public: size_t count() const; int16_t operator[](size_t i) const; int16_t& operator[](size_t i); };
84. class Audio { public: size_t count() const; int16_t operator[](size_t i) const; int16_t& operator[](size_t i); double timeAtZero() const; double sampleRate() const; };
85. class Audio { public: size_t count() const; int16_t operator[](size_t i) const; int16_t& operator[](size_t i); double timeAtZero() const; double sampleRate() const; double verticalScale() const; };
86. class Audio { public: size_t count() const; int16_t operator[](size_t i) const; int16_t& operator[](size_t i); double timeAtZero() const; double sampleRate() const; double verticalScale() const; std::string fileName() const; std::string comments() const; bool isStereo() const; void loadFromFile(const std::string& filename); void saveToFile(const std::string& filename); };
88. What is an audio clip?
90. Sound changing
 continuously
 over time
91. Audio : (a : Type) -> Type Audio a = (Float -> Maybe a)
92. Audio : (a : Type) -> Type Audio a = (Float -> Maybe a)
93. template <typename T> class Audio { boost::optional<T> operator()(double t); };
94. clip : (Audio a) -> Float -> Float -> (Audio a)
95. template <typename T> Audio<T> clip(Audio<T>, double, double);
96. Further exploration
97. The Intellectual Ascent to Agda David Sankel
 C++Now 2013
 https://youtu.be/vy5C-mlUQ1w
98. Open Source Bridge
101. –Christopher McDougall,
 Born to Run “What else did we have going for us? Nothing, except we ran like crazy and stuck together.”
102. So, build like hell
 and stick together!
103. Enjoy the conference!
104. Image credits https://www.flickr.com/photos/nettsu/4570198529 https://en.wikipedia.org/wiki/Fun_(band)#/media/File:Fun._band.jpg https://www.flickr.com/photos/hodgers/450003437 https://www.flickr.com/photos/ikoma/21423567 https://www.flickr.com/photos/sharynmorrow/222401409 https://media2.giphy.com/media/EldfH1VJdbrwY/200.gif https://www.flickr.com/photos/ladybeames/2896787167 chrismcdougall.com