7li7w devcon5

What I learned fromSeven Languagesin Seven WeeksKerry Buckley (@kerryb) – DevCon5 25/5/12

Twenty-

RubyIoPrologScalaErlangClojureHaskell

What is the typing model?What is the programming model?How will you interact with it?What are the decision constructsand core data structures?What are the core features thatmake the language unique?

Java was like having a rich lawyer as a brother. He wasfun when he was younger, but now he’s a black holethat sucks away all the joy in a 100-mile radius.

Meet Ruby, one of my favorites. She’s sometimes quirky,always beautiful, a little mysterious, and absolutely magical.

The irb console>> puts "Hello world"Hello world=> nil>> name = "Kerry"=> "Kerry">> puts "Hello #{name}"Hello Kerry=> nil

Everything’s an object>> 42.class=> Fixnum>> nil.class=> NilClass>> String.class=> Class> 42.methods=> [:to_s, :+, :-, :*, :/, :abs, ...

Duck typingdef double(x) x * 2end>> double(2)=> 4>> double(2.5)=> 5.0>> double("foo")=> "foofoo">> double(false)NoMethodError: undefined method `* for false:FalseClass from (irb):2:in `double

Arrays, ranges & hashes>> array = [1, 2.0, "three"]>> array[0]=> 1>> array.reverse=> ["three", 2.0, 1]>> range = (1..10)>> range.include? 5=> true>> hash = {:foo => 123, "bar" => "", 456 => [1, 2]}>> hash[456]=> [1, 2]

Blocks & yield>> 3.times { puts "hello" }hellohellohello>> File.open "some-file", "w" do |f|?> f.write "some-data">> end>> def delayed_by seconds>> sleep seconds>> yield>> end>> delayed_by 5 do?> puts "At last!">> endAt last!

Open classesclass NilClass def blank? true endendclass String def blank? empty? endend>> [nil, "", "foo"].map &:blank?=> [true, true, false]

Modules & mixinsmodule Debug def info "#{self.class}[#{object_id}]: #{to_s}" endendclass Object include Debugend>> 2.info=> "Fixnum[5]: 2">> "foo".info=> "String[70107061928320]: foo"

Collections & Enumerable class MyCollection include Enumerable def each ... end end >> MyCollection.instance_methods.sort => [:all?, :any?, :chunk, :collect, :collect_concat, :count, :cycle, :detect, :drop, :drop_while, :each, :each_cons, :each_entry, :each_slice, :each_with_index, :each_with_object, :entries, :find, :find_all, :find_index, :first, :flat_map, :grep, :group_by, :include?, :inject, :map, :max, :max_by, :member?, :min, :min_by, :minmax, :minmax_by, :none?, :one?, :partition, :reduce, :reject, :reverse_each, :select, :slice_before, :sort, :sort_by, :take, :take_while, :to_a, :zip]

method_missing magicclass MyStruct def initialize values @values = values end def method_missing name, *args @values[name] endend>> struct = MyStruct.new foo: 123, bar: 456=> #<MyStruct:0x007fc2c21433b8 @values={:foo=>123, :bar=>456}>>> struct.foo=> 123>> struct.bar=> 456

Dynamic definitionclass MyStruct def initialize values @values = values end def method_missing name, *args puts "Defining method #{name}" self.class.class_eval do define_method(name) { @values[name] } end send(name, *args) endend>> struct.fooDefining method foo=> 123>> struct.foo=> 123

ProsPower and ﬂexibilityDeveloper productivity and funRaw execution speedLimited concurrency supportType-aware tool support Cons

Io is a rule bender. He’s young, wicked smart, and easy tounderstand but hard to predict. He might give you the ride ofyour life, wreck your dad’s car, or both.

Message passingIo> "oI olleH" reverse==> Hello IoIo> list("iH", "oI") map(reverse)==> list(Hi, Io)Io> list(1, 2, 3) map(** 2) sum==> 14

Objects & SlotsIo> Person := Object clone==> Person_0x7f922c06ad00: type = "Person"Io> Person firstName := "John"==> JohnIo> Person lastName := "Doe"==> DoeIo> Person firstName==> John

Defining methodsIo> Person name := method ( firstName .. " " .. lastName)Io> Person name==> John Doe

Prototypal inheritanceIo> Arthur := Person clone==> Arthur_0x7fd5406cd860: type = "Arthur"Io> Arthur name==> John DoeIo> Arthur firstName = "Arthur"Io> Arthur lastName = "Dent"Io> Arthur name==> Arthur DentIo> Arthur proto==> Person_0x7fd540693ed0: firstName = "John" lastName = "Doe" name = method(...) type = "Person"

Control structuresIo> for(i, 1, 3, i println)123==> 3Io> if(true, "Yes" println, "No" println)Yes==> Yes

ReflectionIo> foo := method( call sender println call message arguments println)Io> foo("bar", 42) Object_0x7fcf78418920: Lobby = Object_0x7fcf78418920 Protos = Object_0x7fcf78417c00 ...list("bar", 42)

CoroutinesIo> Ping := Object cloneIo> Pong := Object cloneIo> Ping ping := method ( 2 repeat("Ping!" println; yield))Io> Pong pong := method ( 2 repeat(yield; "Pong!" println))Io> Ping @@ping; Pong @@pongIo> Coroutine currentCoroutine pausePing!Pong!Ping!Pong!

ActorsIo> Slow := Object cloneIo> Fast := Object cloneIo> Slow go := method( wait(1) "Slow" println)Io> Fast go := method( "Fast" println)Io> Slow @@go; Fast @@go; wait(2)FastSlow

FuturesIo> page := URL with( "http://google.co.uk/") @fetchIo> "Im in the foreground" printlnIm in the foregroundIo> page size println16906

ProsTiny – ideal for embedded systemsPrototypes and duck typing are very ﬂexibleConcurrency supportSimple, consistent syntaxRaw execution speedSmall user community Cons

Sometimes spectacularly smart, other times just as frustrating. You’llget astounding answers only if you know how to ask the question.

Simple factslikes(wallace, cheese).likes(gromit, cheese).likes(wendolene, sheep).?- likes(wallace, sheep).false.?- likes(gromit, cheese).true.?- likes(Who, cheese).Who = wallace ;Who = grommit.

Evaluating rulesfriend(X, Y) :- +(X = Y), likes(X, Z), likes(Y, Z).?- friend(wallace, wallace).false.?- friend(wendolene, gromit).false.?- friend(wallace, gromit).true.

Recursive rulesfather(grandpa, homer).father(homer, bart).ancestor(X, Y) :- father(X, Y).ancestor(X, Y) :- father(X, Z), ancestor(Z, Y).?- ancestor(Who, bart).Who = homer ;Who = grandpa ;false.

Tuples?- (X, Y, Z) = (1, 2, "foo").X = 1,Y = 2,Z = [102, 111, 111].?- (X, _, Z) = (1, 2, "foo").X = 1,Z = [102, 111, 111].

Calculation with listssum(0, []).sum(Total, [Head|Tail]) :- sum(Sum, Tail), Total is Head + Sum.?- sum(What, [1, 2, 3]).What = 6.

Solving (4×4) sudoku?- sudoku([_, _, 2, 3, _, _, _, _, _, _, _, _, 3, 4, _, _], Solution).Solution = [4,1,2,3,2,3,4,1,1,2,3,4,3,4,1,2].

Solving (4×4) sudokusudoku(Puzzle, Solution) :- Solution = Puzzle, Puzzle = [S11, S12, S13, S14, S21, S22, S23, S24, S31, S32, S33, S34, S41, S42, S43, S44], Solution ins 1..4, Row1 = [S11, S12, S13, S14], Row2 = [S21, S22, S23, S24], Row3 = [S31, S32, S33, S34], Row4 = [S41, S42, S43, S44], Col1 = [S11, S21, S31, S41], Col2 = [S12, S22, S32, S42], Col3 = [S13, S23, S33, S43], Col4 = [S14, S24, S34, S44], Square1 = [S11, S12, S21, S22], Square2 = [S13, S14, S23, S24], Square3 = [S31, S32, S41, S42], Square4 = [S33, S34, S43, S44], valid([Row1, Row2, Row3, Row4, Col1, Col2, Col3, Col4, Square1, Square2, Square3, Square4]).valid([]).valid([Head|Tail]) :- all_different(Head), valid(Tail).

ProsSolving logical and scheduling problemsNatural language processingArtiﬁcial intelligenceScaling requires deep understandingNot a general-purpose languageSimple procedural tasks are difﬁcult Cons

He was often awkward, was sometimes amazing, but always had aunique expression. Sometimes, his scissors let him do incredible things.Other times, he was awkward and humiliated.

Type inference & coercion scala> "foo" res0: java.lang.String = foo scala> 123 res1: Int = 123 scala> 45.6 res2: Double = 45.6 scala> 1 + 2.3 res3: Double = 3.3 scala> "The answer is " + 42 res4: java.lang.String = The answer is 42

var & valscala> var a = 42a: Int = 42scala> a = a + 1a: Int = 43scala> val earth = "Harmless"earth: java.lang.String = Harmlessscala> earth = "Mostly Harmless"<console>:8: error: reassignment to val earth = "Mostly Harmless" ^

Ranges & tuplesscala> val range = 0 to 3range: scala.collection.immutable.Range.Inclusive = Range(0, 1, 2, 3)scala> val range = 0 to 5 by 2range: scala.collection.immutable.Range = Range(0, 2, 4)scala> val tuple = ("Kerry", 42)tuple: (java.lang.String, Int) = (Kerry,42)scala> val (name, age) = tuplename: java.lang.String = Kerryage: Int = 42

Lists, sets & mapsscala> val list = List(1, 2, 3)list: List[Int] = List(1, 2, 3)scala> list(1)res0: Int = 2scala> "zero"::listres1: List[Any] = List(zero, 1, 2, 3)scala> Set(1, 2, 3) ++ Set(2, 3, 4)res2: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)scala> val map = Map(1 -> "One", 2 -> "Two")map: scala.collection.immutable.Map[Int,java.lang.String] = Map(1 -> One, 2 -> Two)scala> map(1)res3: java.lang.String = One

Defining classesclass Person(firstName: String, lastName: String) { def greet(name: String) { println("Hello " + name + ", Im " + firstName + ".") }}scala> val kerry = new Person("Kerry", "Buckley")kerry: Person = Person@276bab54scala> kerry.greet("DevCon")Hello DevCon, Im Kerry.

Companion objectsclass Person(firstName: String, lastName: String) { ...}object Person { def find(id: Int) { val (first, last) = DB.people.find(id) new Person(first, last }}

Extending & traitsclass Person(val name:String)trait Nice { def greet() = println("Howdily doodily.")}class Character(override val name:String) extends Person(name) with Nicescala> val flanders = new Character("Ned")scala> flanders.greetHowdily doodily.

List processingscala> val jedi = List("Yoda", "Obiwan", "Luke")jedi: List[java.lang.String] = List(Yoda, Obiwan, Luke)scala> jedi.filter(name => name.size < 5)res0: List[java.lang.String] = List(Yoda, Luke)scala> jedi.map(name => name.size)res1: List[Int] = List(4, 6, 4)scala> val numbers = List(1, 2, 3)numbers: List[Int] = List(1, 2, 3)scala> numbers.foldLeft(0)((a, n) => a + n)res2: Int = 6

Class hierarchy Any AnyVal AnyRefFloat Int … ScalaObject … List Map Nothing Null

First-class XMLscala> val pets = <pets> <chicken>Babs</chicken> <chicken>Bunty</chicken> <chicken>Lily</chicken> <cat>Pebbles</cat> <chicken>Pepper</chicken> <cat>Twiglet</cat> <cat>Willow</cat> <cat>Zorro</cat></pets>scala> pets "cat"res0: scala.xml.NodeSeq = NodeSeq(<cat>Twiglet</cat>, <cat>Pebbles</cat>, <cat>Willow</cat>, <cat>Zorro</cat>)

Pattern matchingscala> (pets "_").foreach {pet => pet match { case <cat>{name}</cat> => println(name + " says meow.") case <chicken>{name}</chicken> = println(name + " says cluck.") }}Babs says cluck.Bunty says cluck.Lily says cluck.Pebbles says meow.Pepper says cluck.Twiglet says meow.Willow says meow.Zorro says meow.

Concurrency with actorscase object Strokecase object Feedclass Cat() extends Actor { def act() { loop { react { case Stroke => { println("Purr!") } case Feed => { println("Om nom nom") } } } }}scala> val cat = new Cat().startscala> cat ! Stroke; cat ! Feed; println("Done.")Done.Purr!Om nom nom

ProsA modern version of JavaMixins, pattern matching, blocks, XMLConcurrency with actors & immutabilityStatic typingCompromises with mutable state Cons

Agent Smith was an artiﬁcial intelligence program in the matrix thathad an amazing ability to take any form and bend the rules ofreality to be in many places at once. He was unavoidable.

The usual types (mostly)1> 2 + 2.42> "Hello"."Hello"3> atom.atom4> {foo, 123, "bar"}.{foo,123,"bar"}5> [1, "one", two].[1,"one", two]6> [87, 84, 70, 63]."WTF?"

Variables don’t change1> Foo = 42.422> Foo = Foo + 1.** exception error: no match of right hand side value 433> Values = [1, 2, 3].[1,2,3]4> lists:append(Values, [4]).[1,2,3,4]5> Values.[1,2,3]

Pattern matching1> Pet = {{name, "Zorro"}, {type, "Cat"}}.{{name,"Zorro"},{type,"Cat"}}2> {{name, Name}, {type, Type}} = Pet.{{name,"Zorro"},{type,"Cat"}}3> Name."Zorro"4> Type."Cat"5> [Head|Tail] = [foo, bar, baz].[foo,bar,baz]6> {Head, Tail}.{foo,[bar,baz]}

Bit matching1> [A, B, C, D] = [1, 0, 50, 200].[1,0,50,200]2> Packed = <<A:1, B:1, C:6, D:8>>.<<"²È">>3> <<P:1, Q:1, R:6, S:8>> = Packed.<<"²È">>4> {P, Q, R, S}.{1,0,50,200}

Basic functions-module(demo).-export([echo/1]).echo(Value) -> Value.1> c(demo).{ok,demo}5> demo:echo("Hello")."Hello"6> demo:echo(42).42

Patterns in functions-module(fact).-export([fact/1]).fact(0) -> 1;fact(N) -> N * fact(N-1).1> c(fact).{ok,fact}3> fact:fact(6).7204> fact:fact("foo").** exception error: bad argument in an arithmeticexpression in function fact:fact/1 (fact.erl, line 5)6> fact:fact(10000).

Patterns in functions28462596809170545189064132121198688901480514017027992307941799942744113400037644437729907867577847758158840621423175288300423399401535187390524211613827161748198241998275924182892597878981242531205946599625986706560161572036032397926328736717055741975962099479720346153698119897092611277500484198845410475544642442136573303076703628825803548967461117097369578603670191071512730587281041158640561281165385325968425825995584688146430425589836649317059251717204276597407446133400054194052462303436869154059404066227828248371512038322178644627183822923899638992827221879702459387693803094627332292570555459690027875282242544348021127559019169425429028916907219097083690539873747452483372899521802363282741217040268086769210451555840567172555372015852132829034279989818449313610640381489304499621599999359670892980190336998484404665419236258424947163178961192041233108268651071354516845540936033009607210346944377982349430780626069422302681885227592057029230843126188497606560742586279448827155956831533440534425446648416894580425709461673613187605234982286326452921529423479870603344290737158688499178932580691483168854251956006172372636323974420786924642956012306288720122652952964091508301336630982733806353972901506581822574295475894399765113865541208125788683704239208764484761569001264889271590706306409661628038784044485191643790807186112370622133415415065991843875961023926713276546986163657706626438638029848051952769536195259240930908614471907390768585755934786981720734372093104825475628567777694081564074962275254993384112809289637516990219870492405617531786346939798024619737079041868329931016554150742308393176878366923

Higher order functions1> Double = fun(X) -> X * 2 end.#Fun<erl_eval.6.111823515>2> Double(2).43> List = [1, 2, 3].[1,2,3]4> lists:map(Double, List).[2,4,6]5> lists:map(fun(X) -> X + 1 end, List).[2,3,4]6> lists:foldl(fun(X, Sum) -> X + Sum end, 0, List).6

List comprehensions1> Numbers = [1, 2, 3, 4].[1,2,3,4]2> Double = fun(X) -> X * 2 end.#Fun<erl_eval.6.111823515>3> lists:map(Double, Numbers).[2,4,6,8]4> [Double(X) || X <- Numbers].[2,4,6,8]5> [X || X <- Numbers, X > 1, X < 4].[2,3]6> Basket = [{pencil, 4, 0.25}, {pen, 1, 1.20}, {paper, 2, 1.00}].[{pencil,4,0.25},{pen,1,1.2},{paper,2,1.0}]7> Totals = [{Item, Qty * Price} || {Item, Qty, Price} <- Basket].[{pencil,1.0},{pen,1.2},{paper,2.0}]

Message loops-module(doubler).-export([loop/0]).loop() -> receive N -> io:format("~b~n", [N * 2]), loop()end.18> Doubler = spawn(fun doubler:loop/0).<0.87.0>19> Doubler ! 2.4

Synchronous messages-module(doubler).-export([loop/0, double/2]).loop() -> receive {Pid, N} -> Pid ! (N * 2), loop()end.double(To, N) -> To ! {self(), N}, receive Result -> Result end.27> Doubler = spawn(fun doubler:loop/0).<0.118.0>28> doubler:double(Doubler, 3).6

Monitor & restart-module(monitor).-export([loop/0, start/0]).loop() -> process_flag(trap_exit, true), receive new -> register(doubler, spawn_link(fun doubler:loop/0)), loop(); {EXIT, From, Reason} -> io:format("~p exited: ~p.", [From, Reason]), monitor ! new, loop()end.start() -> register(monitor, spawn(fun monitor:loop/0)), monitor ! new.

ProsDesigned for concurrency & fault toleranceFlexibility of dynamic typingLightweight processes with message passing & monitoringBuild scalable applications with the OTP librarySyntax sometimes a little clumsyIntegration with other languages Cons

His communication style is often inverted and hard to understand.He seems too small to make a difference, but it quickly becomesapparent that there is more to Yoda than meets the eye.

Prefix notationuser=> (+ 2 2)4user=> (- 10 4 1)5user=> (/ 2.0 3)0.6666666666666666user=> (/ 2 3)2/3user=> (count "hello")5user=> (+ (count "hello") (count "clojure"))12

Java hiding underneathuser=> (class 1)java.lang.Integeruser=> (class "foo")java.lang.Stringuser=> (class (= 2 2))java.lang.Booleanuser=> (class (/ 1 2))clojure.lang.Ratio

Data or code?user=> (1 2 3)java.lang.ClassCastException: java.lang.Integer cannot becast to clojure.lang.IFn (NO_SOURCE_FILE:0)user=> (list 1 2 3)(1 2 3)user=> (class (list 1 2 3))clojure.lang.PersistentListuser=> (1 2 3)(1 2 3)user=> (class (+ 2 2))clojure.lang.PersistentListuser=> (eval (+ 2 2))4

Vectors, sets & mapsuser=> (def numbers [1 2 3])(1 2 3)user=> (conj numbers "forty-two")[1 2 3 "forty-two"]user=> (def crew #{:zaphod :trillian :marvin})#user/crewuser=> (clojure.set/union crew #{:ford :zaphod :arthur})#{:arthur :trillian :ford :zaphod :marvin}user=> (def home {:arthur :earth, :ford :betelgeuse, :marvin :sirius})#user/homeuser=> (home :arthur):earthuser=> (:arthur home):earth

Defining functionsuser=> (defn answer [] 42)#user/answeruser=> (answer)42user=> (defn treble [a] (* 3 a))#user/trebleuser=> (treble 20)60

Destructuring paramsuser=> (def board [[:x :o :x] [:o :x :o] [:o :x :o]])#user/boarduser=> (defn centre [[_ [_ c _] _]] c)#user/centreuser=> (centre board):x

Anonymous functionsuser=> (defn treble [a] (* 3 a))#user/trebleuser=> (def numbers [1 2 3])#user/numbersuser=> (map treble numbers)(3 6 9)user=> (map (fn [n] (* 3 n)) numbers)(3 6 9)user=> (map #(* 3 %) numbers)(3 6 9)

Recursion: loop & recuruser=> (defn size [v] (if (empty? v) 0 (inc (size (rest v)))))#user/sizeuser=> (size [1 2 3])3user=> (defn size [v] (loop [l v, c 0] (if (empty? l) c (recur (rest l) (inc c)))))

Working with sequencesuser=> (def numbers [1 2 3 4])#user/numbersuser=> (every? odd? numbers)falseuser=> (filter odd? numbers)(1 3)user=> (for [x numbers] (* 2 x))(2 4 6 8)user=> (for [x numbers, y numbers] (* x y))(1 2 3 4 2 4 6 8 3 6 9 12 4 8 12 16)user=> (for [x numbers, y numbers, :when (odd? x)] (* x y))(1 2 3 4 3 6 9 12)

Lazy evaluationuser=> (take 5 (cycle ["I" "am" "what"]))("I" "am" "what" "I" "am")user=> (take 5 (drop 2 (cycle [1 2 3])))(3 1 2 3 1)user=> (->> [1 2 3] (cycle) (drop 2) (take 5))(3 1 2 3 1)user=> (take 5 (iterate inc 1))(1 2 3 4 5)user=> (defn factorial [n] (apply * (take n (iterate inc 1))))#user/factorialuser=> (factorial 5)120

Records & protocolsuser=> (defprotocol Shape (area [this]))Shapeuser=> (defrecord Square [width height] Shape (area [this] (* width height)))user.Squareuser=> (defrecord Circle [radius] Shape (area [this] (* (. Math PI) (* radius radius))))user.Circleuser=> (area (Square. 2 3))6user=> (area (Circle. 4))50.26548245743669

Macro expansionuser=> (defn unless [test body] (if (not test) body))#user/unlessuser=> (unless true (println "Its a lie!"))Its a lie!niluser=> (defmacro unless [test body] (list if (list not test) body))#user/unlessuser=> (macroexpand (unless condition body))(if (not condition) body)user=> (unless true (println "Its a lie!"))niluser=> (unless false (println "Its true!"))Its true!nil

Transactional memoryuser=> (def ford (ref {:name "Ford Prefect", :from "Guildford"}))#user/forduser=> (deref ford){:name "Ford Prefect", :from "Guildford"}user=> @ford{:name "Ford Prefect", :from "Guildford"}user=> (alter ford assoc :from "Betelgeuse")java.lang.IllegalStateException: No transaction running(NO_SOURCE_FILE:0)user=> (dosync (alter ford assoc :from "Betelgeuse")){:name "Ford Prefect", :from "Betelgeuse"}user=> @ford{:name "Ford Prefect", :from "Betelgeuse"}

Encapsulation with atoms user=> (def numbers (atom [1 2 3])) #user/numbers user=> numbers #<Atom@7d98d9cf: [1 2 3]> user=> @numbers [1 2 3] user=> (reset! numbers [4 5 6]) [4 5 6] user=> (swap! numbers conj 7) [4 5 6 7]

Agents in the background user=> (defn slow-twice [x] (do (Thread/sleep 5000) (* 2 x))) #user/slow-twice user=> (def number (agent 2)) #user/number user=> number #<Agent@4c825cf3: 2> user=> @number 2 user=> (send number slow-twice) #<Agent@4c825cf3: 2> user=> @number 2 user=> @number 4

Back to the futuresuser=> (def ultimate-answer (future (do (Thread/sleep 2.4e17) 42)))#user/ultimate-answeruser=> @ultimate-answer42

ProsA good lisp implementationAccess to Java ecosystemConcurrency provided by STMPreﬁx notation can be confusing(((((and all those parens don’t help)))))Some limitations compared to other lisps Cons

Haskell represents purity and freedom, but the power comes at aprice. Think Spock from Star Trek. His character has a single-mindedpurity that has endeared him to generations.

Type inferencePrelude> :set +tPrelude> 4242it :: IntegerPrelude> "Mostly harmless""Mostly harmless"it :: [Char]Prelude> "black" == "white"Falseit :: BoolPrelude> 1/20.5it :: Double

Defining functionsPrelude> let double x = x * 2double :: Num a => a -> aPrelude> double 48Prelude> double 2.55.0Prelude> let times x y = x * ytimes :: Num a => a -> a -> aPrelude> times 5 630

Specifying function types module Main where double :: Integer -> Integer double x = 2 * x Prelude> :load main [1 of 1] Compiling Main ( main.hs, interpreted ) Ok, modules loaded: Main. *Main> double 2 4 *Main> double 2.5 <interactive>:1:8: No instance for (Fractional Integer) arising from the literal `2.5

Pattern matching & guards module Main where factorial :: Integer -> Integer factorial 0 = 1 factorial x = x * factorial (x - 1) factorial2 :: Integer -> Integer factorial2 x | x > 1 = x * factorial2 (x - 1) | otherwise = 1

Tuples & listsPrelude> let zaphod = ("Zaphod", "Beeblebrox", "Betelgeuse", 2)Prelude> let (_, _, _, numberOfHeads) = zaphodPrelude> let numbers = [1, 2, 3, 4]Prelude> let (head:tail) = numbersPrelude> head1Prelude> tail[2,3,4]Prelude> 1:[2, 3][1,2,3]Prelude> [1, "two"]<interactive>:1:2: No instance for (Num [Char]) arising from the literal `1 Possible fix: add an instance declaration for (Num [Char]) In the expression: 1 In the expression: [1, "two"] In an equation for `it: it = [1, "two"]

Ranges & sequencesPrelude> [1..5][1,2,3,4,5]Prelude> [2, 4 .. 10][2,4,6,8,10]Prelude> [0, 0.5 .. 2][0.0,0.5,1.0,1.5,2.0]Prelude> take 5 [1 ..][1,2,3,4,5]

List comprehensionsPrelude> let numbers = [1,2,3]Prelude> [x * 2 | x <- [1, 2, 3]][2,4,6]Prelude> [[x, y] | x <- numbers, y <- numbers][[1,1],[1,2],[1,3],[2,1],[2,2],[2,3],[3,1],[3,2],[3,3]]Prelude> [[x, y] | x <- numbers, y <- numbers, x < y][[1,2],[1,3],[2,3]]Prelude> let more_numbers = [4,5]Prelude> [(x, y, x * y) | x <- numbers, y <- more_numbers, x < y][(1,4,4),(1,5,5),(2,4,8),(2,5,10),(3,4,12),(3,5,15)]

Function curryingPrelude> 4 * 520Prelude> (*) 4 520Prelude> :t (*)(*) :: Num a => a -> a -> aPrelude> let double = (* 2)Prelude> :t doubledouble :: Integer -> IntegerPrelude> double 36

Higher order functionsPrelude> (x -> 2 * x) 510Prelude> map (x -> 2 * x) [1, 2, 3][2,4,6]Prelude> map (* 2) [1, 2, 3][2,4,6]Prelude> filter odd [1, 2, 3, 4][1,3]Prelude> foldl (+) 0 [1, 2, 3, 4]10

Type classesclass Eq a where (==), (/=) :: a -> a -> Bool -- Minimal complete definition: -- x/=y x==y (==) or (/=) = not(x==y) = not(x/=y)*Main> :info Integerdata Integer = integer-gmp:GHC.Integer.Type.S# GHC.Prim.Int# | integer-gmp:GHC.Integer.Type.J# GHC.Prim.Int#GHC.Prim.ByteArray# -- Defined in integer-gmp:GHC.Integer.Typeinstance Enum Integer -- Defined in GHC.Numinstance Eq Integer -- Defined in GHC.Classesinstance Integral Integer -- Defined in GHC.Realinstance Num Integer -- Defined in GHC.Numinstance Ord Integer -- Defined in GHC.Classesinstance Read Integer -- Defined in GHC.Readinstance Real Integer -- Defined in GHC.Realinstance Show Integer -- Defined in GHC.Num

User-defined typesmodule Main where data Shape = Circle Float | Rectangle Float Float deriving show area :: Shape -> Float area (Circle r) = pi * r ^ 2 area (Rectangle x y) = x * y*Main> let circle = Circle 10*Main> let rect = Rectangle 6 7*Main> area circle314.15927*Main> area rect42.0*Main> [circle, rect][Circle 10.0,Rectangle 6.0 7.0]

Record syntaxmodule Main where data Shape = Circle {radius :: Float} | Rectangle {width :: Float, height :: Float} deriving Show area :: Shape -> Float area (Circle r) = pi * r ^ 2 area (Rectangle x y) = x * y*Main> let circle = Circle 10*Main> let rect = Rectangle 6 7*Main> [circle, rect][Circle {radius = 10.0},Rectangle {width = 6.0, height = 7.0}]

MonadsA monad is a construction that, given an underlying typesystem, embeds a corresponding type system (calledthe monadic type system) into it (that is, each monadictype acts as the underlying type). This monadic typesystem preserves all signiﬁcant aspects of theunderlying type system, while adding features particularto the monad.Monads must obey the following rules:• (return x) >>= f ≡ f x• m >>= return ≡ m• (m >>= f) >>= g ≡ m >>= ( x -> (f x >>= g) )

The maybe monaddata Maybe a = Nothing | Just aPrelude> case (html doc) of Nothing -> Nothing Just x -> case body x of Nothing -> Nothing Just y -> paragraph 2 yinstance Monad Maybe where return = Just Nothing >>= f = Nothing (Just x) >>= f = f xPrelude> Just someWebPage >>= html >>= body >>= paragraph >>= return

ProsPure functional language with no side effectsStrong typing with powerful type inferenceLaziness reduces need for recursionIdeal for learning the functional paradigm Inﬂexibility and lack of compromiseSmall community outside academiaSteep learning curve (especially monads!) Cons

What I learned fromSeven Languagesin Seven Weeks

Functional styledef total_price(widgets) total = 0 widgets.each do |widget| if widget.red? total += widget.price end end totalenddef total_price(widgets) widgets.select{|w| w.red?}.map{|w| w.price}.reduce(&:+)end

JVM or standalone?• Access to Java libraries• Deployment environments• Escape route for Java developers• Limitations (eg tail recursion)

Know what’s out there• Languages• Features • First-class functions • List comprehensions • Pattern matching • Lazy evaluation

Dealing with concurrency • Immutability • Coroutines • Actors • Futures • Software Transactional Memory

Creditshttp://pragprog.com/book/btlang/seven-languages-in-seven-weekshttp://www.ﬂickr.com/photos/oskay/472097903/http://www.ﬂickr.com/photos/clairedancer/273214248

7li7w devcon5

by Kerry Buckley on May 30, 2012

Accessibility

Categories

Upload Details

Usage Rights

Statistics

7li7w devcon5 Presentation Transcript