Functional Languages 101: What’s All the Fuss About?

Recorded at:

Getting lost again by Petr Sobotka

• Reply
• Back to top

Re: Getting lost again by Scott Gregory

• Reply
• Back to top

Re: Getting lost again by Rashid Jilani

• Reply
• Back to top

Does functional language have the chance to become popular among mortals? by Chou Harry

• Reply
• Back to top

Re: Does functional language have the chance to become popular among mortal by Chou Harry

• Reply
• Back to top

Re: Getting lost again by Dmitry Tsygankov

• Reply
• Back to top

Re: Getting lost again by Paul Topping

• Reply
• Back to top

Code in Clojure by Alexandru Repede

(defn my-length [lst]
    (loop [len 0 x lst]
        (if (empty? x)
            len
            (recur (+ 1 len) (rest x)))))

user=> (my-length '(1))
1
user=> (my-length '(1 2 3 4))
4
user=> (my-length '())
0

(defn squares [lst]
    (loop [sqrs '() x lst]
       (if (empty? x)
           (reverse sqrs)
           (recur (cons (* (first x) (first x)) sqrs) (rest x)))))

user=> (squares '(1 2 3 4))
(1 4 9 16)

(defn my-map [func lst]
    (loop [res '() x lst]
       (if (empty? x) 
           (reverse res) 
           (recur (cons (func (first x)) res) (rest x)))))

user=> (my-map (fn [x] (* x 2)) '(1 2 3))
(2 4 6)

• Reply
• Back to top

Re: Getting lost again by Anton Ivanov

• Reply
• Back to top

Re: Does functional language have the chance to become popular among mortal by Gresham Paul

• Reply
• Back to top

Re: Does functional language have the chance to become popular among mortal by Gresham Paul

• Reply
• Back to top

Code in Scala by Steve Thompson

   // A is a generic parameter, match/case is akin to a switch/case
   // mechanism in Java, Nil denotes an empty list, and the => 
   // operator in this context separate the case from its associated
   // logic.  Return is not used as Scala methods return the last
   // expression evaluated. 

   def length[A](list: List[A]): Int = list match {
      case Nil              => 0
      case first :: theRest => 1 + length(theRest)
   }

   // Notice the lambda (anonymous function) given to map
   def timesTwo(values: List[Int]): List[Int] = 
      values.map((value: Int) => value * 2)

   // or, more simply because of type inference

   def timesTwo(values: List[Int]): List[Int] = 
      values.map(value => value * 2)

   // or, even simpler still (because creating an identifier for
   // each value just adds more ceremony to our code), here is
   // the same with 'placeholder' syntax

   def timesTwo(values: List[Int]): List[Int] = values.map(_ * 2)

   // Typical open resource/do something with resource/close resource
   public <T> void save(T item)
   {
      Connection connection = Db.openConnection();
      try { connection.store(item); } finally { connection.close(); }
   }

   // We'll pass in a function as a parameter.  The signature for this
   // is Connection => Unit, which basically means the function takes
   // a Connection but doesn't return anything.
   def transact(f: Connection => Unit): Unit = {
      val connection = Db.openConnection()
      try{ f(connection) } finally { connection.close() }
   }

   // Now our save can be very DRY
   def save[A](item: A) = transact(_.store(item))

   // And similarly other operations
   def delete[A](item: A) = transact(_.delete(item))

   // This can be easily tied into collections.  Note that this is
   // potentially much more efficient than calling transact repeatedly    
   // for each item
   def deleteAll[A](items: List[A]) = transact(items foreach _.delete)

• Reply
• Back to top

Availability of Parser Combinator Example? by Morgan Creighton

• Reply
• Back to top

Use of continuations for parallel workflows by Nermin Serifovic

• Reply
• Back to top

Re: Getting lost again by Jack Repenning

• Reply
• Back to top