Slashdot Mirror

.. a set of riddles that require a little bit of Python programming to be solved.

This book teaches functional programming as a way of thinking and problem solving, using Haskell, the most popular purely functional language. Rather than using the conventional mathematical examples commonly found in other programming language textbooks, the author draws examples from multimedia applications, including graphics, animation, and computer music, thus rewarding the reader with working programs for inherently more interesting applications. Aimed at both beginning and advanced programmers, this tutorial begins with a gentle introduction to functional programming and moves rapidly on to more advanced topics. An underlying theme is the design and implementation of domain specific languages, using three examples: FAL (a Functional Animation Language), IRL (an Imperative Robot Language), and MDL (a Music Description Language)...

 Template Haskell is an extension to Haskell 98 that allows you to do type-safe compile-time meta-programming, with Haskell both as the manipulating language and the language being manipulated.

Intuitively Template Haskell provides new language features that allow us to convert back and forth between concrete syntax, i.e. what you would type when you write normal Haskell code, and abstract syntax trees. These abstract syntax trees are represented using Haskell datatypes and, at compile time, they can be manipulated by Haskell code. This allows you to reify (convert from concrete syntax to an abstract syntax tree) some code, transform it and splice it back in (convert back again), or even to produce completely new code and splice that in, while the compiler is compiling your module. 

12.3 Code Replacement

Erlang supports change of code in a running system. Code replacement is done on module level.

The code of a module can exist in two variants in a system: current and old. When a module is loaded into the system for the first time, the code becomes 'current'. If then a new instance of the module is loaded, the code of the previous instance becomes 'old' and the new instance becomes 'current'.

Both old and current code is valid, and may be evaluated concurrently. Fully qualified function calls always refer to current code. Old code may still be evaluated because of processes lingering in the old code...

> cMajScale = Tempo 2
>      (line [c 4 en [], d 4 en [], e 4 en [], f 4 en [],
>          g 4 en [], a 4 en [], b 4 en [], c 5 en []])
> cMajScale = Tempo 2
>      (line [c 4 en [], d 4 en [], e 4 en [], f 4 en [],
>          g 4 en [], a 4 en [], b 4 en [], c 5 en []])
fac n = product [1..n]
rec
qsort []  = []
qsort (x:xs) = qsort elts_lt_x ++ [x] ++ qsort elts_greq_x
        where
         elts_lt_x = [y | y <- xs, y < x]
         elts_greq_x = [y | y <- xs, y >= x]
lst
theList
l
head
h
tail
t
h
t
l
i
j
foo
bar
baz
less
greater
let tr_map f lst =
 let rec map_helper f lst acc =
  match lst with
    [] -> List.rev acc
  | head::tail -> map_helper f tail ((f head)::acc) in
 map_helper f lst [];;
from sys import stdin
print "Who are you?"
name = stdin.readline().strip()
print "I'm glad to meet you, %s." % name
main = interact ((++) "Who are you?\n" .
        (++) "I'm glad to meet you, " .
        ((++) `flip` ".\n") . head . lines )
import java.io.*;

class Hello {
  public static void main (String[] args) throws IOException {
    BufferedReader ki = new BufferedReader(new
              InputStreamReader(System.in));

    System.out.println("Who are you?");
    String name = ki.readLine();
    System.out.println("I'm glad to meet you, " + name + ".");
  }
}
invert :: [(Int,Int)] -> [(Int,Int)]
invert = map (\(a,b) -> (b,a))
-- Inverting an array that holds a permutation of its indices
invPerm :: (Ix a) => Array a a -> Array a a
invPerm a = array b [(a!i, i) | i <- range b]
  where b = bounds a

Slashdot Mirror

Domain: haskell.org

Comments · 393