∃ PROLOG | PROLOG ∈ SCALA

Links mentioned in the talk:

CIA document: http://www.foia.cia.gov/search-results?search_api_views_fulltext=SW+90-10029X&field_collection=
The Art of Prolog: http://mitpress.mit.edu/books/art-prolog
Shapeless: https://github.com/milessabin/shapeless
Fun with typefunctions: http://research.microsoft.com/en-us/um/people/simonpj/papers/assoc-types/fun-with-type-funs/typefun.pdf
Promoting functions to type families: http://www.cis.upenn.edu/~eir/papers/2014/promotion/promotion.pdf
HCategoryTheory: https://github.com/mandubian/injective/blob/shapeless-ext/src/main/scala/ShapelessExt.scala

Demo code is here: https://github.com/folone/2014-scala.io

Transcript

1. ∃ PROLOG |
   PROLOG ∈ SCALA
2. About me: @folone like types* *same reasons why @propensive does in his “Batshit crazy algebra with types” talk
3. def validate[F[_], G, H, V <: HList, I <: HList, M <: HList, A <: HList, R](g: G)(v: V)(implicit hlG: FnHListerAux[G, A => R], zip: ZipApplyAux[V, I, M], mapped: MappedAux[A, F, M], unH: FnUnHListerAux[I => F[R], H], folder: LeftFolderAux[M, F[A => R], applier.type, F[HNil => R]], appl: Applicative[F]) = unH((in: I) => folder(zip(v, in), hlG(g).point[F]).map(_(HNil)))
4. 8+ implicits FnHipsterAux
5. LOGIC PROGRAMMING
6. PROgrammation en LOGique, 1972, 5GL Lingua franca
7. — Alan J. Perlis A language that doesn't affect the way you think about programming, is not worth knowing.
8. BURAN
9. IBM Watson http://www.ibm.com/smarterplanet/us/en/ibmwatson/developercloud/services-catalog.html
11. Main principles It's all about formulating the question. Facts (ground terms) Rules (to generate more facts) RELATIONS > FUNCTIONS WHAT > HOW
12. PREDICATES > FUNCTIONS Map inputs to outputs Run Return some output Define constraints Match Only return yes or no* *If "yes", they may add bindings to variables. log(2, 16, 4). log(2, 16) = 4
13. How many PROLOG programmers does it take to change a lightbulb? —
14. NO.
15. PACKAGE MANAGER
16. Facts depends(scala, java). depends(java, gcc). depends(ghc, clang). depends(erlang, prolog). depends(erlang, clang). depends(prolog, gcc).
17. ?- depends(scala, prolog). no ?- depends(java, gcc). yes ?- depends(prolog, X). X = gcc. ?- depends(erlang, X). X = prolog ; X = clang. Questions
18. Questions ?- depends(What, OnWhat). What = scala, OnWhat = java; What = java, OnWhat = gcc; What = ghc, OnWhat = clang; What = erlang, OnWhat = prolog; What = erlang, OnWhat = clang; What = prolog, OnWhat = gcc.
19. common_dep(Pack1, Pack2) :- 
 depends(Pack1, Topic), 
 depends(Pack2, Topic), 
 Pack1 \== Pack2. ?- common_dep(java, What).
 What = prolog. Rules
20. Facts provides(scala, scalac). provides(scala, scala). provides(erlang, erl). provides(java, javac). provides(prolog, swipl). provides(ghc, ghci).
21. deps_needed(Package, What) :- depends(Package, What). deps_needed(Package, What) :- depends(Package, X), depends(X, What).
22. ?- deps_needed(scala, What). What = java ; What = gcc. Questions
23. deps_to_run(Command, What) :- provides(What, Command). deps_to_run(Command, What) :- provides(X, Command), deps_needed(X, What). Rules
24. ?- deps_to_run(erl, What). What = erlang ; What = prolog ; What = clang ; What = gcc. Questions
25. install(Dep) :- installed(Dep). install(Dep) :- assert(installed(Dep)), write('Installing '), write_term(Dep, []), write('\n'), installed(Dep).
26. run(Command) :- findall(Dep, deps_to_run(Command, Dep), L), reverse(L, Deps), forall(member(Dep, Deps), install(Dep)), write('Running '), write_term(Command, []), write('\n'), !.
27. ?- run(ghci). Installing clang Installing ghc Running ghci true. ?- run(erl). Installing gcc Installing prolog Installing erlang Running erl true.
28. github.com/larsyencken/marelle
29. Functional is imperative without state. Logic is functional without manual search*. * DFS
30. Scala is a logic programming language...
31. In type system. programming language...
32. In type system. programming in Scala is... TYPELEVEL
33. logic programming in Scala programming in Scala is...
34. gcd(X, X, X). gcd(X, Y, Out) :- X < Y Z is Y - X gcd(X, Z, Out). gcd(X, Y, Out) :- Y < X, gcd(Y, X, Out). Prolog
37. Facts — implicit vals. Rules — implicit defs taking implicit vals as parameters. Implication is the other way around.
38. The more interesting your types get, the less fun it is to write them down. – Benjamin Pierce —
39. • Scala does not perform the DFS. In case of multiple implicits, it does not compile. Prioritizing implicits via inheritance. • Diverging implicit expansion -Xlog-implicits. • Extremely hard to debug (pen and paper style). • Peculiar exceptions (SO in compiler, Method too large, etc.) Gotchas
40. So now I need to redefine all the goodness from prolog stdlib?! Lists, naturals, etc. Shapeless: stdlib for logic programming in scala. —
41. DEMO github.com/folone/2014-scalaio
42. Functional in the small, OO in the large, logic in the type system!
43. Promoting Functions to Type Families in Haskell HMonoid, HFunctor, HApplicative, HMonad Related Fun with type functions The art of Prolog Shapeless
44. @milessabin @xeno_by @travisbrown @larsr_h @killnicole Thanks
46. ?– (λx.folonexlambda-calcul.us)@